文章目录
- attribute_Error
- basic
- class_object
- data_base
- data_structure
- file
- function
- if-while-for
- module_new
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=1t','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('1234n'))
# print(f.writelines(['2345n','3456n','5678n']))
# f.close()
# 使用with open()函数读写文件:
with open('11.txt','w') as f:
f.write('1234n')
with open('11.txt','a') as f:
f.writelines(['3456n'])
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=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:UsersCDLXPycharmProjectsT23期day5module.py
# print(os.path.abspath('./file.py')) #C:UsersCDLXPycharmProjectsT23期day5file.py
# print(os.path.abspath('../111.py')) #C:UsersCDLXPycharmProjectsT23期111.py
# print(os.path.abspath('./test/test1.py')) #C:UsersCDLXPycharmProjectsT23期day5testtest1.py
# print(os.path.abspath('/file1.txt')) #C:file1.txt
# print(os.path.abspath('module.py')) #C:UsersCDLXPycharmProjectsT23期day5module.py
# print(os.path.abspath('__init__.py')) #C:UsersCDLXPycharmProjectsT23期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:UsersCDLXPycharmProjectsT23期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)
