wenxinjin

attribute_Error

class People(object):
    def __init__(self, country='中国', province='陕西省'):
        self.country = country
        self.province = province

    @classmethod
    def is_country(cls):
        return cls.country

    @classmethod
    def is_province(cls):
        return cls.province


def main():
    print(People.is_country())
    print(People.is_province())


if __name__ == '__main__':
    main()

basic

# -*- coding:utf-8 -*-
# print('hello world!')

'''
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
*objects:
# 1.*args   不定长参数, 元祖, 0-多个
# 2.**kwargs 不定长参数, 字典, 0-多个
sep:
分隔符,默认以空格分隔
end:
结束符,默认以回车换行结束
file
文件流,默认输出到系统的标准输出设备(显示屏)
flush
缓存方式,默认不缓存,直接输出
'''
#
#
# print()
# print(1,2,3)
# print(1,2,3,sep="@")
# print(1,2,3,end='*******************')
# print(4)

# print('hello world!')
# print("hello world!")
# print('''
# this is a hello world program!
# ''')

# 演示print()函数
# print("it's mine")
# print('it\'s mine')
# print('1',2,3)
# print(1,2.88,sep=': ')
# print(1,2,3,end="       ")
# print(4)
# print('-'*50)
# print('1.鱼香肉丝')
# print('2.宫保鸡丁')
# print('-'*50)
# print('1*1=1\t','1*2=2')
# print()
# print('c:\\note.txt')
# print(r'c:\note.txt')

# input('what is your name? \n')
# print('hello')

# input('what is your name?')

# word = input('input a word: \n')
# print(word)

# import keyword
# print(keyword.kwlist)

# 数据类型:
# 4种基本数据类型: 整数类型(int),小数类型(float),字符串(str),布尔类型(bool)
# sex = 'male'
# print(type(sex))
# sex = 0
# print(type(sex))
#
#
# print(10+100)

# num1 = 10
# num2 = '100'
# print(num1+num2)

'''
小练习：
1根据用户输入的年龄信息，程序输出结果“Your age is : XXX”
2：提示用户输入你的薪资:用户从键盘上接收数据，之后对薪资+1000，打印输出调整后的薪资是--
'''

# age = int(input('请输入你的年龄:\n'))
# # print('your age is : ', age)
# print(('your age is : %d'%age))



# sal = input('请输入你的薪资信息: \n')
# print('调整后的薪资是: ',int(sal)+1000)

# print(str(1))
# print(str(3.1415926))
# print(str(True))
# print(str(False))
# print(int(2.16))
# print(float(2))
# print('*'*50)
# print(bool(0))
# print(bool(None))
# print(bool(''))
# print(bool({}))
# print('*'*50)
# print(bool(1))
# print((bool(' ')))
# print(bool({1}))
#
# print(int(1.89)+1)
#
# print(int('1.34'))

print("我在汇智动力%s期学习"%'T23')
print("I'm %s. I'm %d year old" %('Obama',59))
print("I'm %(name)s. I'm %(age)d year old" %{'age':59,'name':'Obama'})
print("圆周率π是%08.2f" %3.1415)

print("%*.*f" %(5,2,3.14159))

class_object

# 类的构成(三要素):
# 1.类名
# 2.类属性(可以在对象之间共享)
# 3.类方法

# 创建对象:
# 对象名=类名(参数1,参数2)
# 创建对象过程发生了三件事:
# 1.先向内存中申请一段地址空间来保存对象(例:0x0011)
# 2.自动调用类中的__init__方法来初始化对象
# 3.把创建完成的对象地址值返回给对象名(0x0011)

# 使用点运算符来访问类的属性或类的方法，例:类.属性名,类.方法名(self),对象的属性是用self.属性名来访问
# 对象.方法名 等价于 类.方法名(self)

# 封装,继承,多态:
# 封装:指的是对数据或代码的封装,使得数据或代码有安全性保护,或易于维护或修改
# 继承:子类能够继承超类的属性和方法，通过这种继承机制，相同的属性就不需要被重复编写，因此很好的实现了代码重用
# 多态:定义的时候用父类,调用的时候用子类,这样扩大了代码的可传值和复用方式,这是一种设计方法.

# class Car:
#     num = 0
#     def __init__(self,w,c):
#         self.wheel_num = w
#         self.color = c
#         Car.num += 1
#         print(Car.num,self.wheel_num,self.color,self)
#         print()
#     def run(self):
#         print('小汽车会跑!')
#
# c = Car(4,'red')
# c.run()
# print(c.num)
import os
'''
1.设计一个工资类(Salary)，其中的数据成员有：
salary_al代表所有员工工资;
整型值number表示的在职工人数。
调用你自己设计好的成员函数完成下面的功能：

1). 输入职工工资，工资保存到salary列表中，实际人数保存到number中（输入-1标志着工资输入结束）；
2). 给每个人涨300元工资；
3). 对涨后的工资进行排序；
4). 输出排序后的工资
'''

# class Salary:
#     salary_al = 0
#     number = 0
#     salary_list = []
#     update_sal_list = []
#     def __init__(self,salary):
#         self.salary = salary
#         Salary.number +=1
#         Salary.salary_al += self.salary
#         if self.salary != -1:
#             Salary.salary_list.append(self.salary)
#     def add_salary(self):
#         Salary.salary_al = 0
#         for temp in Salary.salary_list:
#             update = temp + 300
#             Salary.update_sal_list.append(update)
#             Salary.salary_al += update
#     def sort_update_salary(self):
#         Salary.update_sal_list.sort()
#     def print_update_salary(self):
#         for temp in Salary.update_sal_list:
#             print(temp)
#
# s1 = Salary(1200)
# print(s1.number)
# print(s1.salary_al)
# print(s1.salary_list)
#
# s2 = Salary(800)
# print(s2.number)
# print(s2.salary_al)
# print(s2.salary_list)
#
# print('*'*50)
# s2.add_salary()
# print(s2.update_sal_list)
# print(s2.salary_al)
#
# print('*'*50)
# s2.sort_update_salary()
# print(s2.update_sal_list)
#
# print('*'*50)
# s2.print_update_salary()


# class Student:
#     def __init__(self,n,w):
#         self.weight = w
#         self.name = n
#     def run(self):
#         self.weight -= 0.5
#     def eat(self):
#         self.weight +=1
#
# s1=Student('lilei',75)
# s1.eat()
# s1.eat()
# s1.eat()
# print(s1.weight)
#
# s2=Student('Hanmeimei',45)
# s2.run()
# s2.run()
# s2.run()
# s2.run()
# print(s2.weight)

# class Student:
#     def __init__(self,name,s_id):
#         self.name = name
#         self.s_id = s_id
#
#     def study(self):
#         print('好好学习,天天向上!')
#
# class T23_Student(Student):
#     def study(self):
#         print('我要学会测试!')
#
# s1 = T23_Student('yj','S001')
# print(s1.name,s1.s_id)
# s1.study()

# class Parent:        # 定义父类
#     parentAttr = 100
#     def __init__(self):
#         print("调用父类构造函数")
#     def parentMethod(self):
#         print('调用父类方法')
#     def setAttr(self, attr):
#         Parent.parentAttr = attr
#     def getAttr(self):
#         print("父类属性 :", Parent.parentAttr)
#
# class Child(Parent):
#     def __init__(self):
#         print("调用子类构造方法")
#     def childMethod(self):
#         print('调用子类方法')
# c = Child()
# c.childMethod()
# c.parentMethod()
# c.setAttr(200)
# c.getAttr()


class Parent1:
    def myMethod(self):
        print('调用父类方法1')
class Parent2:
    def myMethod(self):
        print("调用父类方法2")
class Child(Parent2,Parent1):
    def myMethod(self):
        print('调用子类方法')
c = Child()
c.myMethod()

data_base

import pymysql
try:
    conn = pymysql.connect(host='127.0.0.1',port=3306,user='root',password='root',db='pirate',charset='utf8')
except:
    print('连接失败')
else:
    cur = conn.cursor()
    list = [[107, 'zt01', 25, 'male'], [108, 'zt02', 26, 'male']]
    # sql = 'select * from hd_user'
    # sql = 'update hd_user set username = \'zhangsi\' where id = 1'
    # sql = 'insert into student(id,name) values(1001,\'yuerqwe11\')'
    # sql = 'delete from student where id = 1001'
    try:
        # row = cur.execute(sql)
        cur.executemany("insert into student(id,name,age,sex) values(%s,%s,%s,%s)", list) #executemany可以一次插入多行
        # if sql.strip().lower().startswith('select'): #stip() 去空格；startswith('select')以引号内的字符开头
        #     print(cur.fetchall())
        # elif sql.strip().lower().startswith('update'):
        #     if row == 0:
        #         print('OK')
        #     else:
        #         print('没成功!')
        # else:
        #     print(row)
        conn.commit()
        cur.close()
        conn.close()
    except:
        print('sql没有执行成功!')
        conn.rollback()










#存储过程
    def getmonery(cursor, name="xiaoming", num=200):
        cursor.callproc("getmonery", (name, num))
        cursor.execute('''
        create procedure getmonery(IN name varchar(10), IN tmp int)
        begin
          declare s int default 0;
          select sal into s from salary where pname=name;
          if s > tmp then
            update salary set sal = s-tmp where pname=name;
            commit ;
          else
            select "余额不足";
          end if ;
        end;
        ''')
        print(cursor.fetchall())
        # create procedure getmonery(IN name varchar(10), IN tmp int)
        # begin
        #     declare s int default 0;
        #     select sal into s from salary where pname=name;
        #     if s > tmp then
        #       update salary set sal = s-tmp where pname=name;
        #       commit ;
        #     else
        #       select "余额不足";
        #     end if ;
        # end;

















# import pymysql
# try:
#     conn = pymysql.connect(host='127.0.0.1',port=3306,user='root',password='root',database = 'pirate',charset='utf8')
# except:
#     print('连接不成功')
# else:
#     cur = conn.cursor()
#     sql = ' select * from hd_user where id = 1'
#     # sql = 'update hd_user set username = \'zhangsan\' where id = 1'
#     # sql = 'insert into student(id,name) values(2002,\'hoj\')'
#     # sql = 'delete from student where id = 2001'
#     cur.execute(sql)
#     if sql.lstrip().startswith('select'):
#         res = cur.fetchall()
#         print(res)
#     else:
#         print('OK!')

data_structure

# # python内建数据结构:
# 1.列表
# 定义方式:
# (1).列表中的元素是定义在[]中
# (2).元素和元素之间是用,分隔的(不能用别的符号)
# (3).列表当中的元素可以是任意数据类型
# (4).列表是可变的,可以增删改查
list1 = [1,'2',3.9,True,[1,2]]
# 遍历和查询:
# 方式一:
# for temp in list1:
#     print(temp)
# 方式二:
# for num in range(len(list1)):
#     print(list1[num])
# 查询值(可以为负数,相当于倒着数):
# print(list1[3])
# print(list1[-1])
# 查询索引:
# print(list1.index(1))

# 增加:
# 追加:

# list1.append('hello')
# print(list1)
# 在现有基础上做插入:
# list1.insert(2,'hi')
# print(list1)
# +来操作两个列表的合并
# list2 = [77,88]
# list = list1 + list2
# print(list)
# 列表末尾追加一个序列的元素(列表,元祖,字典均可),缺点:没有返回值.
# list2 = [77,88]
# list1.extend(list2)
# print(list1)
# list1.append(list2)
# print(list1)
# 删除:
# pop删除不带索引,默认删除最后一个,带索引,删除对应的那个值.
# pop删除的时候,会返回删除的这个值.
# list1.pop()
# print(list1)
# a = list1.pop()
# print(a)

# 注意:del删除如果不带索引,就是删除整个列表.带索引就删除对应的那个值.
# del(list1[1])
# print(list1)

# # 修改:
# list1[0] = 'a'
# print(list1)

# 列表的其他函数:
# max()取最大值,min()取最小值,count()返回指定元素在列表中出现的次数,reverse()逆序,sort()排序
# list = [1,33,6,4,8,9,2,1.89,2,2]
# list1 = ['a','b','c','d','3','6']
# max_num = max(list1)
# print(max_num)
# min_num = min(list)
# print(min_num)
# count_num = list.count(3.3)
# print(count_num)
# list.reverse()
# print(list)
# list.sort()
# print(list)

# 注意:reversed()函数返回值类型为obj(列表的基类),所以不能直接打印查看.
# reversed()和sorted()函数不会改变列表本身,所以需要用新列表去接收逆序和排序的结果.
# list_new = reversed(list)
# for temp in list_new:
#     print(temp)
# print(list_new)
# print(list)
# list_new = sorted(list)
# print(list_new)
# print(list)

# 列表的嵌套:
# list_a = [1,2,3,4,[11,22,[123,234]]]
# print(list_a[4][2][0])

# 2.元祖
# 定义方式:
# (1).元祖中的元素是定义在()中
# (2).元素和元素之间是用,分隔的(不能用别的符号)
# (3).元祖当中的元素可以是任意数据类型
# (4).元祖是不可变的,所以只能查
# (5).如果元祖只有一个元素,则该元素后必须跟,
# tuple1 = (11,'22',13.9,1,[11,22])
# tuple2=(11,)
# 遍历和查询:
# 方式一:
# for temp in tuple1:
#     print(temp)
# # 方式二:
# for num in range(len(tuple1)):
#     print(tuple1[num])
# # 查询值:
# print(tuple1[3])
# # 查询索引:
# print(tuple1.index(1))

# 3.字典
# 定义方式:
# (1).字典中的元素是定义在{}中
# (2).元素和元素之间是用,分隔的(不能用别的符号),一个元素为键值对的组合,键和值之间用:分隔
# (3).字典当中的元素可以是任意数据类型
# (4).字典也是可变的,所以可以增删改查
# dict1 = {'name':'王英强','age':23,'sex':'male','marriaged':False,'phone':13320003000}
# 遍历和查询
# 按键去遍历
# for key in dict1.keys():
#     print(key)
# 按值去遍历
# for value in dict1.values():
#     print(value)
# 按键值对去遍历
# for k,v in dict1.items():
#     print(k,v,sep=':')
# 查询:
# print(dict1['name'])
# 增加:
# dict1['we_chat'] = 13678093400
# print(dict1)
# 删除:
# del[dict1['age']]
# print(dict1)
# 清空字典:
# dict1.clear()
# print(dict1)
# 修改字典:
# dict1['name']='刘胡兰'
# print(dict1)

# 索引和切片:
# 切片就是取到原来序列的一部分(相当于子集),[]中第一个数表示开始位置,默认从0开始,第二个数表示结束位置,默认为len()的值
# 第三个数也有步长的功效,还有逆序的功效.
# list1 = ['a',11,22,33,'b',44,55]
# print(list1[1:5:2])
# print(list1[::-1])


# 字符串的索引(下标)和切片:
# 字符串的索引和切片同列表
str = 'hello it is my cat! hello! hello!'
# print(str[4])
# print(str.find('cat'))
# print(str[-4:-1])
# str1 = 'MY NAME IS 111'
# str2 = 'abc123'
# str3 = '一二三123'
# str4 = '789'
# str5 = ' my teacher '
# str6 = '888my teacher8888'
#字符串常用方法:
# capitalize 首字母大写
# print(str.capitalize())
# print(str)
# casefold  字符小写(python3.3以后的方法)
# print(str1.casefold())
# count 查找子串的个数
print(str.count('cat',0,19))
# find 查找指定字符,返回索引
# print(str.find('cat'))
# isalnum 判断字符串是否由字母和数字组成
# print(str2.isalnum())
# isalpha  判断是否由字母组成。
# print(str2.isalpha())
# isdigit 判断是否只有数字
# print(str4.isdigit())
# isnumeric  检测字符串是否只有数字组成(支持中文数字)。
# print(str3.isnumeric())
# lower 转换所有大写为小写字母
# # print(str1.lower())
# # Upper转换所有小写为大写字母
# # print(str.upper())
# # lstrip 截掉第一个字符左边空格或指定字符
# # print(str5,str6)
# # print(str5.lstrip())
# print(str6.lstrip('8'))
# # rstrip 截掉第一个右边空格或指定字符
# # strip 截掉左右的空格或指定字符
# # print(str5.strip())
# '''
# str.replace(old, new, max) old -- 将被替换的子字符串;
# new -- 新字符串，用于替换old子字符串; max -- 可选字符串, 替换不超过 max 次
# '''
# # print(str.replace('hello','hi',1))
# # split()方法会把字符串按照其中的空白字符进行分割，最终返回一个列表
# # print(str)
# li = str.split()
# # print(str.split('!'))
# # join()方法拼接列表，需要先指定一个拼接符号，然后使用这个拼接符号调用join()方法，将列表作为参数传递给join()方法
# print(li)
# print(' '.join(li))
# print(','.join(li))

# my_str ='123 I like 456 chinese  ^&*'
# # 方法一:
# li = my_str.split()
# print(li)
# new_str = li[1]+' '+li[2]+' '+li[4]
# print(new_str)
# # 方法二:
# li1 = li[1:3]
# li1.append(li[4])
# print(li1)
# str_new = ' '.join(li1)
# print(str_new)

file

# 打开文件的命令：open('文件名' [,'打开方式'])
# 文件名可以是文件的完整路径，也可以是相对路径，如果不指定文件路径，默认在程序代码的相同路径下
# 打开方式：r/缺省--只读   w--写  a--追加
# w:会将原有的内容覆盖掉，如果文件不存在，则系统自动创建该文件
# a ：写入模式，将新的内容追加到文件末尾
# 读取完成后，记得使用close( )关闭文件，释放资源

# 读取文件三个函数:
# read()  以字符串方式将文件所有内容读取出来
# readline()按行读取文件内容
# readlines()把文件按行读取到一个列表中

# f = open(r'C:\file1.txt')
# print(f.read())
# print(f.readline())
# print(f.readline())
# print(f.readline())
# print(f.readline())
# print(f.readline())
# print(f.readlines())
# f.close()

# 写入文件两个函数:
# write()  以字符串方式将所有内容一次性写入文件中
# writelines()把列表中存的内容按行写入到文件中
# f = open(r'C:\file2.txt','w')
# # # print(f.write('1234\n'))
# print(f.writelines(['2345\n','3456\n','5678\n']))
# f.close()

# 使用with open()函数读写文件:
with open('11.txt','w') as f:
    f.write('1234\n')

with open('11.txt','a') as f:
    f.writelines(['3456\n'])

with open('11.txt') as f:
    print(f.readlines())

import csv
# with open('11.csv','w') as f:
#     w = csv.writer(f)
#     w.writerow(['1','2','3'])
# with open('11.csv','r') as f:
#     r = csv.reader(f)
#     for i in r:
#         print(i)

function

# 函数:
# 1.函数内定义的变量不能在函数外使用
# 2.函数定义里的参数称为形参,函数调用时传入的参数称为实参,形参和实参默认必须一一对应
# 3.函数的传参有如下几种方式:
# 按位传参(个数和位置必须一一对应)
# 关键字传参(位置不需要一一对应,个数必须一一对应)
# 默认参数(已经传了默认值的参数,可以传值也可以不传,非默认参数,必须传,而且非默认参数必须全部在默认参数的前面)
# 4.return语句用于跳出函数或从函数返回值
# 5.函数中如果不指定返回值,相当于return None
# 6.函数内部的变量称为局部变量,只作用于函数内.在全局范围内定义的变量称为全局变量,作用域为全局.
# 7.如果在函数内想要使用全局变量,必须用global来申明.注意申明后,即可以改变全局变量的值,所以需要慎重
# 8.函数内可以再去调用函数,规则就是从哪里调用,从哪里返回
# 9.递归函数,递归函数是函数内部调用函数的一个典型例子,递归函数内必须规定递归的退出条件,否则会成为死循环
# 10.匿名函数,一般用于简单计算或某些一次性的功能,定义语法规则为:lambda 参数1,参数2'''参数N:需要执行的语句,
# 调用规则为:变量=匿名函数,
# 变量(参数1,参数2'''参数N)

# def sum(a,b):
#     print(a,b,a+b)
#
# sum(5,2)       #按位传参
# sum(b=2,a=5)   #关键字传参
# print(1,2,3,4,5,end=' ',sep='@')
# print(7,8,9)

# def person(name,age):
#     print('name is ',name)
#     print('age is ',age)
# person('zhangsan',13)

'''
2:一个计算器程序，要求用户输入两个整数和一个运算符，
程序能够计算出两个数的相应加减乘除结果。（涉及到精确度的，一律保留两位小数，使用输出格式）
'''
# def caculator(num1,num2,opr):
#     res = 0
#     if opr == '+':
#         res = num1+num2
#     elif opr == '-':
#         res = num1 - num2
#     elif opr == '*':
#         res = num1 * num2
#     elif opr == '/':
#         res = num1/num2
#     else:
#         print('输入错误')
#     print(num1,opr,num2,'结果是:%.2f'%res)
#
# caculator(10,3,'+')

# def log_info(name,age,sex,city='西安'):
#     print('姓名是:',name)
#     print('年龄是: ',age)
#     print('性别是: ',sex)
#     print('所在的城市是: ',city)
#     return name
#
# a = log_info('zhangsan',18,'男','西安') #按位置传参
# print(a)
# # log_info(city='西安',age=19,sex='女',name='xiaohong') #按关键字传参
# log_info('lisi',22,'男','咸阳') #按默认值传参

# name = 'admin'
# pwd = '123456'
# def login(user_name,pass_word):
#     global name
#     name = 'admin11'
#     login_name = 'admin'
#     login_pwd = '123456'
#     if user_name == login_name:
#         if pass_word == login_pwd:
#             print('登录成功')
#         else:
#             print('登录失败')
#     else:
#         print('登录失败')
#     print('函数内的name是:',name)
# login(name,pwd)
# print('函数外的name是:',name)
# print(login_name)
# print(login_pwd)
# login('admin1','123456')
# login('admin','12345')


# 递归实现n的阶乘
# def calum(n):
#     res = 1
#     if n > 1:
#         res = n * calum(n-1)
#     else:
#        res = 1
#     return res
# print(calum(10))

# 匿名函数:
# s = lambda a,b:a+b
# print(s(2,3))
# 
# a = lambda a,b:a-b
# print(a(2,3))

if-while-for

# 1.if控制流:
# 单if结构:
if True:
    pass

# 特点:结构简单,条件表达式为True,就执行下面的语句.

# if-else结构:
if True:
    pass
else:
    pass

# 嵌套结构(最多三层嵌套就可以了,否则影响效率):
if True:
    if True:
        pass
    else:
        pass

if True:
    if True:
        pass
    else:
        pass
else:
    pass

# if-elif-else结构:
if True:
    pass
elif True:
    pass
else:
    pass

# 如果a<b，进行加法运算，否则进行减法运算
# a = int(input('请输入一个整数:'))
# b = int(input('请输入一个整数:'))
# if a < b:
#     print(a+b)
# else:
#     print(a-b)

# 2：设计登录，如果用户名正确，提示登录成功，否则提示登录失败
# login_name = 'admin'
# username = input('请输入您的登录名:')
# if username == login_name:
#     print('登录成功')
# else:
#     print('登录失败')


# guess = int(input('请输入一个数字(1-100):'))
# num = 10
# if guess >=1 and guess <= 100:
#     if guess > num:
#         print('大了')
#     elif guess < num:
#         print('小了')
#     else:
#         print('猜中了')
# else:
#     print('输入错误!')


# 完善登录，如果用户名正确，进一步判断密码是否正确，如果正确，提示登录成功，否则提示登录失败
# user_name = 'admin'
# pass_word = '123456'
# login_name = input('请输入你的用户名:')
# login_pwd = input('请输入你的密码:')
# if login_name == user_name and login_pwd == pass_word:
#         print('登录成功')
# else:
#     print('登录失败')

# 当第一个条件为假的情况下,逻辑与运算不需要计算第二个条件的结果
# print(True and int(input('请输入你的数字:'))>3 )
# print(False and int(input('请输入你的数字:'))>3 )
# 当第一个条件为真的情况下,逻辑或运算不需要计算第二个条件的结果
# print(True or int(input('请输入你的数字:'))>3 )
# print(False or int(input('请输入你的数字:'))>3 )

'''
要求用户输入学生的分数，输入的分数在0-100范围内：如果分数在90分或以上，打印优秀；如果分数在80分或以上且在
90以下，打印中；如果分数在60分以上且在80以下，打印一般；如果分数低于60分，打印不及格
'''
# score = int(input('请输入你的分数(0-100):'))
# if score >=0 and score<=100:
#     if score >= 90:
#         print('优秀')
#     elif score >= 80:
#         print('中')
#     elif score >= 60:
#         print('一般')
#     else:
#         print('不及格')
# else:
#     print('输入错误!')

# 2.while循环流,while和for循环都可以接else,当while和for循环正常循环结束的时候,就执行else,
# 当如果while和for是通过break结束的时候,不会执行else:

# i=1
# while i<=10:
#     pass
#     i += 1

# 需求：打印1-10的数字
# i = 1
# while i<=10:
#    print(i)
#    i += 1

# 计算1到100所有的和
# i=1
# sum = 0
# while i<=100:
#     sum = sum + i
#     i += 1
# print(sum)

# 思考  不计算50
# i=1
# sum = 0
# while i<=100:
#     if i == 50:
#         i += 1
#         continue
#     sum = sum + i
#     i += 1
# print(sum)

# continue和break的区别在于,continue是退出本次循环,break是直接退出所在的while循环.

'''
练习1：猜100以内数字游戏，程序内先设定被猜的数值。
 用户给出的值偏小则给出提示“太小”；
用户给出的值偏大，给出提示“太大”，
最多只能猜5次。
猜中了给出提示“恭喜你！”；
如果5次都没猜正确，给出“太笨了！”。
'''
# i = 1
# while i <= 5:
#     guess = int(input('请输入一个数字(1-100):'))
#     num = 10
#     if guess >=1 and guess <= 100:
#         if guess > num:
#             print('大了')
#         elif guess < num:
#             print('小了')
#         else:
#             print('猜中了')
#             break
#     else:
#         print('输入错误!')
#     i += 1
# else:
#     print('太笨了')

'''
练习2：打印1-100之间所有的偶数的累加
'''

# i = 1
# sum = 0
# while i <= 100:
#     if i % 2 == 0:
#         sum += i
#     i +=1
# print(sum)
#
# i = 2
# sum = 0
# while i <= 100:
#     sum += i
#     i +=2
# print(sum)

# for循环:
# for i in ():这个结构只会逐一读取()中的元素
# for i in range(开始值,结束值):这个结构会按序列读取range()中的开始元素到结束元素之间所有的值,不包括结束值
# range()函数第一个参数为开始值,第二个参数为结束值,第三个参数为步长.当开始值为0的时候,开始值可以省略.

# for i in (1,10):
#     print(i)
#
# for i in range(1,10):
#     print(i)
#
# for i in range(1,10,2):
#     print(i)


# for i in range(1,6):
#     print('*')
#
# for i in range(1,6):
#     print('*',end=' ')

# for i in range(1,6):
#     print('*'*i)

for i in range(1,10):
    for j in range(i):
        print('%d*%d=%d'%(j+1,i,i*(j+1)),end='\t')
    print()

module_new

# 模块其实就是一个*.py文件
# 可以通过两种方式导入:
# 1.import直接导入模块
# import day3.homework
# 2.from 模块名(包名.模块名) import 函数或变量
# from day3.homework import login

# # from keyword import kwlist
# # print(kwlist)
# login()

# 随机数模块的导入(直接使用模块名或使用模块名的别名的方式)
# import random as rd
# 1.randint()函数,返回指定范围内的随机整数
from random import randint
# print(rd.randint(1,10))
# list = [11,22,33,4,1,2,3]
# 2.sample()函数,随机返回序列中指定长度的元素
# print(rd.sample(list,2))
# 3.choice()函数,随机返回序列中的一个元素
# print(rd.choice(list))

# 自定义的模块，需要注意:模块文件必须位于python环境变量路径下或与当前工程目录在同一路径下.

# 分配办公室问题:
# from random import randint
# teacher_list = ['a','b','c','d','e','f','g','h']
# office = [[],[],[]]
# for i in teacher_list:
#     index = randint(0,2)
#     office[index].append(i)
# print(office)

'''
os 模块
语法: os.path.basename(path) 功能:返回文件名
语法: os.path.basename(path) 功能:返回文件名
语法：join() 功能：将多个路径拼接成一个路径
语法: split() 功能：将路径切割为文件夹部分和当前文件部分
注意: join()和split()是一对可逆的函数
语法：os.path.dirname(path) 功能：去掉文件名，返回目录
语法：os.listdir(path)
功能：输出该路径下的所有文件名称(path = os.getcwd())
语法：os.path.isfile()
功能：用于判断对象是否为一个文件，如果是一个文件则，输出文件名
语法：os.path.isdir()
功能:用于判断对象是否为一个目录
语法：os.path.exists(path)
功能:判断当前的路径是否存在
返回值为：存在返回Ture，不存在返回False
'''
import os
import keyword
# p1 = os.path.abspath(__file__)
# 注意:./回退一级目录,../回退两级目录,/直接回退到盘符,不写默认就是当前路径
# print('@'*50)
# print(os.path.abspath(__file__))     #C:\Users\CDLX\PycharmProjects\T23期\day5\module.py
# print(os.path.abspath('./file.py'))  #C:\Users\CDLX\PycharmProjects\T23期\day5\file.py
# print(os.path.abspath('../111.py'))  #C:\Users\CDLX\PycharmProjects\T23期\111.py
# print(os.path.abspath('./test/test1.py')) #C:\Users\CDLX\PycharmProjects\T23期\day5\test\test1.py
# print(os.path.abspath('/file1.txt'))  #C:\file1.txt
# print(os.path.abspath('module.py'))   #C:\Users\CDLX\PycharmProjects\T23期\day5\module.py
# print(os.path.abspath('__init__.py')) #C:\Users\CDLX\PycharmProjects\T23期\day5\__init__.py
# print('@'*50)
# print(os.path.basename(__file__))
# path1 = 'home'
# path2 = 'hzdl'
# path3 = 'python'
# path4 = 'aaa.py'
# p2 = os.path.join(path1,path2,path3,path4)
# print(os.path.split(p2))
# print(os.path.dirname(p2))
# print('*'*50)
# p3 = os.getcwd()
# print(os.listdir(p3))
# print('*'*50)
# print(p3)
# print(os.path.isfile(p3))
# print(os.path.isdir(p3))
# p4 = r'C:\Users\CDLX\PycharmProjects\T23期\day11'
# print(os.path.exists(p4))
# print('*'*50)
# print(dir(keyword))

# dir()函数是python内建的函数,用来列出模块中的函数\类和变量
# 如果给dir()函数提供一个模块名称,它返回该模块中的名称列表,如果不提供,则返回当前模块的名称列表

# 练习题:
from random import randint

def guess_num():
    num = randint(1,1)
    i = 1
    while i<=5:
        guess = int(input('请猜测一个1-100之间的数:'))
        if guess <=100 and guess >= 1:
            if guess > num:
                if i < 5:
                    print('大了')
            elif guess < num:
                if i < 5:
                    print('小了')
            else:
                print('恭喜你,对了!')
                break
        else:
            print('输入错误,请重新输入')
        i += 1
    else:
        print('你太笨了!答案是:',num)