python基础
一 原码 反码 补码
正数
- 原码反码和补码一样都是对应的这个数的二进制形式
负数
原码是对应的正数的二进制码且第一个数字为1
反码是除符号位其余位是原码取反
补码是将反码加1
二 编码规范、注释、关键字、标识符
1 编码规范
a.一条语句占用一行
b.语句的后面不需要添加任何符号
c.尽量避免在代码中出现中文或者空格
d.一行代码的长度最好不好超过80个字符【代码可读性降低】
e.要区分代码块，使用缩进【if语句，while语句等】
2 注释
注释是编写程序时，写程序的人给代码所做的一种解释性的文字，能提高代码的可读性，方便以后的阅读和维护
注释是解释性文字，在运行程序时，会被程序跳过，不做任何处理【简单来说，在程序中出现的任何内容，如果不想被执行，则都可以将其转化为注释】
方式：
单行注释：#xxxx
多行注释：“”“xxxxx”“” ‘’‘xxxxx’‘’
#这是一个单行注释
"""
这是一个多行注释
多行注释
"""
'''
这是一个多行注释
多行注释
'''
3 关键字
在Python中，已经被赋予了特殊含义的英文单词，如：if,while,break,continue,pass,finally等
【面试题：列出Python中常用的关键字以及的含义】
4 标识【zhi】符【重点掌握】
在Python中，自定义的字符名称
定义合法标识符的规则：规则必须遵守，如果不遵守，代码报错
a.只能由数字，字母和下划线组成
b.开头不能是数字
c.不能使用其他特殊符号
d.不能是Python的关键字
e.不能使用空格或者中文
f.严格区分大小写
定义合法标识符的规范：可以不遵守，如果不遵守，则代码可读性和可维护性不高
a.尽量做到见名知意【一般采用简单的英文单词表示】
b.命名方式：
方式一：Python官方推荐的写法：所有单词的字母全部小写，不同的单词之间使用下划线连接，如：stu_score
方式二：大多数编程语言通用的写法：驼峰命名法
a.大驼峰命名：所有单词的首字母大写，如：StuScore,一般用于类的定义
b.小驼峰命名:除了首单词之外，其他所有单词的首字母大写，如:stuScore
c.常量命名法：所有的单词的所有字母全部大写，不同的单词使用下划线连接
练习：下面那些标识符是合法的
zhangsan abc@123 123abc break
三 数据类型【重点掌握】
计算机用来做数学运算，计算机程序需要处理生活中不同类型的数据，除了除了普通的文本之外，还需要处理图片，音视频，网页等各种各样的数据，处理不同的数据，需要使用不同的类型表示不同的数据
分类：
number:数字类型【整型：整数int，浮点型：小数float，复数：a + bjcomplex】
string：字符串类型str
boolean:布尔类型【只有两个值，分别为True和False】bool
None:空值 数据结构：
list【列表】,tuple【元组】,dict【字典】,set【集合】 特殊：
function:函数class：类
1 type 类型
list1 = [1,2,3]
print(list1)
print(type(list1))#<class 'list'>
print("+++++++++++++++++++++++++++++++++++++")
tuple1 = (1,2,3)
print(tuple1)
print(type(tuple1))#<class 'tuple'>
print("+++++++++++++++++++++++++++++++++++++")
dict1 = {"a":1,"x":10}
print(dict1)
print(type(dict1))#<class 'dict'>
print("+++++++++++++++++++++++++++++++++++++")
set1 = {10,20,30}
print(set1)
print(type(set1))#<class 'set'>
四 常量和变量【重点掌握】
1.常量
程序在运行的过程中，值永远不会发生改变的标识符
本质：仍然是一个变量，但是为了区分，通常使用常量命名法区分常量和变量
常量命名法：所有单词的所有字母全部大写，不同的单词之间使用下划线分隔
2.变量
2.1概念以及定义
程序在运行的过程中，值会随时发生改变的标识符，注意：不但可以改变值，也可以改变类型
语法：标识符 = 值
说明：
标识符：对于每个变量需要给它起一个名称，被称为变量名，也被称为引用
值：第一次给变量赋予的值被称为初始值，但是，该值是可以随时被修改的
#定义一些变量
a=10
print(a)
print(type(a))#<class 'int'>
print("+++++++++++++++++++++++++++++++++")
a=8
print(a)
a="hehe"
print(type(a))#<class 'str'>
print("+++++++++++++++++++++++++++++++++")
print(a)
a='we'
print(type(a))
print("+++++++++++++++++++++++++++++++++")
a=True
print(a)
print(type(a))#<class 'bool'>
print("+++++++++++++++++++++++++++++++++")
a=1.9
print(type(a))#<class 'float'>
print("+++++++++++++++++++++++++++++++++")
a=None#用于把一个变量的值置空
print(type(a))#<class 'NoneType'>
print("+++++++++++++++++++++++++++++++++")
2.2内存中的变量
注意：
a.变量名 = 值，变量名存储在栈空间中，值存储在堆空间中
b.变量中存储数据，实际上存储的是数据的地址
c.定义变量实际上：在内存中开辟了一块空间，将一个指定的数据存储到该空间中，并且给该空间进行了命名
【面试题】注意：如果一个数据没有引用指向的时候，则该数据会被系统的垃圾回收机制回收，目的是为了释放所占用的空间【工作原理：当一个变量的引用计数为0.则说明该变量需要被废弃掉，现在使用的自动管理内存，不需要手动操作一个变量的引用计数】
为了加速Python的执行效率，方便管理内存，让内存空间可以重复利用【内存池】
2.2.1 id()获取地址
#1.id():获取一个变量在内存中的地址，一个数据的地址在内存中是唯一的
a=10
b=10
print(a,b)
print(id(a))#1543284096
print(id(b))
b=9
print(id(a))
print(id(b))
print("++++++++++++++++++++++++++++++++++++")
a="hello"
b="hello"
print(a,b)
print(id(a))
print(id(b))
print("++++++++++++++++++++++++++++++++++++")
a=999
b=999
print(id(a))
print(id(b))
a="uu"
b=a
print(a,b)
print("++++++++++++++++++++++++++++++++++++")
a=None
print(a)
del a
print(a)
2.3删除变量
语法：
del变量名注意：当一个变量被删除之后，该变量所占用的内存空间会被强制释放，同时相当于该变量未被定义
2.4变量类型转换
int:整型float：浮点型bool：布尔型str:字符串
int(xx): 将xx转换为整型【重点掌握】
float(xx): 将xx转换为浮点型
str(xx): 将xx转换为字符串【重点掌握】
bool(xx):将xx转换为布尔型
bin(xx):将数值xx转换为二进制
hex(xx):将数值xx转换为十六进制
oct(xx):将数值xx转换为八进制
chr(xx):将xx整数转换为编码之后对应的一个字符
ord(xx)：将xx字符转换为对应的编码的整数
2.4.1 练习1
a="10"
print(a,type(a))#10 <class 'str'>
a1=int(a)
print(a1,type(a1))#10 <class 'int'>
a="uu"
#a=int(a)#ValueError: invalid literal for int() with base 10: 'uu'
#print(a)
print("++++++++++++++++++++++++++++++++++++++")
a="9.9"
print(a,type(a))
a1=float(a)
print(a1,type(a1))
print("+++++++++++++++++str(xx);将xx转换为字符串【重点掌握】+++++++++++++++++++++")
a=10
a=str(a)
print(a,type(a))
a=[1,2,3]
a1=str(a)
print(a1,type(a1))
print("+++++++++++++++bool(xx):将xx转换为布尔型+++++++++++++++++++++")
#假【False】:0 0.0 "" None [] () {}
print(bool(8))
print(bool(0))
print(bool(0.0))
print(bool(""))
print(bool(None))
print(bool([1,2]))
print(bool([]))
print("+++++++++++++++++++++")
print(bool(()))
print(bool({1}))
print("++++++++++bin(xx):将数值xx转换为二进制++++++++++++++")
print(bin(9))
#print(bin("a"))#TypeError: 'str' object cannot be interpreted as an integer
print(bin(-9))
print("++++++++++++hex(xx):将数值xx转换为十六进制+++++++++++++++++++++")
print(hex(19))
print(hex(90))
print("++++++++++++oct(xx):将数值xx转换为八进制+++++++++++++++")
print(oct(9))
print(oct(90))
2.4.2 练习2 码值
print(ord("a"))
print(ord("z"))
print(ord("A"))
print(ord("Z"))
print(ord("0"))
print(ord("9"))
print(ord("*"))
print("++++++++++++++++++++++++++++")
print(chr(43))
print(chr(123))
print(chr(21320))
2.4.3 练习3 定义一个变量，该变量的值为任意小写字母，输出对应的大写字母
a="s"
juli=ord("a")-ord("A")#先算出大写与小写的距离
print(juli)
mazhi=ord(a)#算出小写字母的码值
print(mazhi)
mazhi_daxie = mazhi-juli#用小写字母的码值减去距离--得到大写的码值
daxie = chr(mazhi_daxie)
print(daxie)
五、输入输出【重点掌握】
1 print 输出
1.1 练习1
#print方法
print(10)
print(90,100)
print("hello "+"uu")
print(10+8)
#print("ww"+9)
print(1*10)
print("*"*10)
print("*"*100)
print("+++++++++++++++++++++++++++++++++++++")
a=2
b=3
print("%d + %d = %d" %(a,b,a+b))
print("%s + %s = %s" %(a,b,a+b))
print("++++++++++++++++++")
a=2.3
b=9.9
print("%f + %f = %f" %(a,b,a+b))
print("%.1f + %.1f = %.1f" %(a,b,a+b))
print("%.2f + %.2f = %.2f" %(a,b,a+b))
print("%d + %d = %d" %(a,b,int(a)+int(b)))
print("%s + %s = %s" %(a,b,a+b))
1.2 练习2 格式输出
%d整数
%f小数%.nf保留n位小数
%s任意类型
"""
姓名:刘备 年龄：30
"""
name="刘备"
age=30
print("姓名:%s 年龄:%d " %(name,age))
#print("%d" %(name))#TypeError: %d format: a number is required, not str
1.3 练习3
sep: 分隔符,默认值为空格，如果想要其他的分隔符，可以自定义【给sep变量重新赋值】
end: 如果想让end=""
#sep:分隔符,默认值为空格，如果想要其他的分隔符，可以自定义【给sep变量重新赋值】
print(2,3)
print(2,3,sep="++++")
print("+++++++++++++++++++++++++++++")
#3.end:结束符,默认值为\n,会进行自动换行，如果不想要换行，可以自定义【给end变量重新赋值】
#如果想让print阻止换行，则可以end=""
print(10,end=",")
print(20,end="")
print(" hehe")
print("+++++++++++++++++++++++++++")
print(1,2,3,sep="*****",end="++++")
print(" killer")
2 input 输入
语法：input(“提示文字”)
结果：输入完数据，按下回车键，则会解除阻塞,同时返回用户输入的数据
注意：不管在控制台上输入了什么类型的数据，通过input获取，获取的都是字符串
num=input("请输入一个数字：")
print(num)
print(type(num))
num=int(num)
print(type(num))
#需求：引导用户输入姓名和年龄，直接输出
#用户名 ： mingzi 年龄 ：100
name = input("请输入您的用户名：")
age = int(input("请输入您的年龄："))
print("用户名:%s 年龄:%d" %(name,age))
六 运算符和表达式【第一部分】
1 表达式
表达式是由操作数和运算符组成的一句代码或者语句
作用：可以赋值，可以运算
例如：
2 + 3就是一个表达式，2和3是操作数，
+是运算符
name = "zhangsan",zhangsan是操作数，=是运算符
2 运算符
2.1 算术运算符
+ - * / %(取余) **(次幂) //(取整)
a = 10
b = 3
print("a=%d b=%d" %(a,b))
print("%d+%d=%d"%(a,b,a+b))
print("%d-%d=%d"%(a,b,a-b))
print("%d*%d=%d"%(a,b,a*b))
print("%d/%d=%f"%(a,b,a/b))
print("%d/%d=%s"%(a,b,a//b))
print("%d余%d=%s"%(a,b,a%b))
print(2**3)
print("+++++++++++++++++++++++")
print(2*5**2)
print((2*5)**2)
2.2 赋值运算符
简单赋值运算符：
=
作用：给一个变量进行赋值复合赋值运算符：
+= -= *= /= %= **= //=
作用：进行指定的运算，然后再给一个变量进行赋值
a=10
print(a)
a=a+10
print(a)
a+=10
print(a)
a**=2
print(a)
a=a**2
2.3 关系运算符
==：等于 !=:不等于 = < <=
注意：运算结束之后的结果肯定是一个布尔值【一个关系表达式的结果无非两种结果，要么成立：True，要么不成立：False】
使用场景：一般用于条件，结合if语句或者while语句使用
a=10
b=9
print("a=%d b=%d" % (a,b))
print(a==b)
print(a!=b)
print(a>b)
print(a>=b)
print(a<b)
2.4 位运算符【了解】
"""
&& || ！ and or not
与 同时为真才是真 只要有一个假就是假
或 同时为假才是假 只要有一个真就是真
非 非真即假 非假即真
与 同时为1才是1 只要有一个0就是0
或 同时为0才是0 只要有一个1就是1
非 非0即1 非0即1
& :按位与 |：按位或
^:按位异或 ~：按位取反
<<:左移 >>:右移
注意：& | ^【面试题】使用较多
"""
a = 10
b = 7
# 0000 1010
# 0000 0111
# 0000 0010
print(a & b)
# 0000 1010
# 0000 0111
# 0000 1111
print(a | b)
# 0000 1010
# 1111 0101---(?==-11)
# 0000 1010
# 1
# 0000 1011---11
print(~a)
print(~b)
#0000 0111
#1111 1000---(?)-8
#0000 0111
#0000 1000
#^:按位异或 相异为真 相同为假
#0000 1010
#0000 0111
#0000 1101
print(a^b)
print("+++++++++++++++++++++++++++++++++++")
#0000 1000
#0001 0000
a = 8
a <<= 4
print(a)
a >>= 5
print(a)
2.5 逻辑运算符
and or not ---- 与或非
a = True
b = False
print(a and a)
print(a and b)
print(b and a)
print(b and b)
print("++++++++++++++++++++++++")
a = 10
b = 3
luoji1 = a>=b and a>9
print(luoji1)
luoji2 = a>=b and a>100
print(luoji2)
print("+++++++++++++++++++++++++++++++++++")
luoji_or1 = a>b or a>900
print(luoji_or1)
luoji_or2 = a<=b or a>900
print(luoji_or2)
print("++++++++++++++++++++++++++++++++++")
luoji3 = not a>=b
print(luoji3)
luoji4 = not 100>900
print(luoji4)
print("========and的优先级高于or====")
luoji5 = 8>7 and 3>9 or 80>9 and 9<90
print(luoji5)
luoji6 = 8>7 and 3>9 or 8>9 and 9<90 or not False
print(luoji6)
七 分支语句之if语句【重点掌握】
Python中的语句分为两大类：分支语句和循环语句
分支语句【条件控制语句】：if语句，根据不同的条件执行不同的语句
循环语句：while语句，for语句
1 单分支【简单if语句】
语法：
if 表达式:
语句块
说明：
a.作用：根据条件是否成立决定语句是否执行【要么执行，要么不执行】
b.表达式可以是常量，变量或者运算符【关系运算符】
c.区分if语句的代码使用的缩进【一定要注意缩进，标准写法为四个空格】
if False:
print("====这是真的====")
print("====这是一个缩进语句块====")
print("++++++++++++++0 0.0 False None [] () {} ++++++++++++++++++++++")
print("====a>10 b<9 =====")
if 1:
print("===分支007===")
a=10
if a>9:
print("===a大于9===")
if a>=1 and a<=100:
print("a在1--100之间==")
if a>=10:
print("a大于等于10")
print("======over++++++")
2 双分支【if-else语句】
语法：
if 表达式:
语句1
else:
语句2
说明：
进行了二选一的操作，如果条件成立，则执行语句1，如果条件不成立，则执行语句2
a = 11
if a % 2 == 0:
print("%d 是偶数" % (a))
else:
print("%d 不是偶数" %(a))
day = int(input("请输入这个月的第几天："))
if day>=10 and day<=20:
print("%d 在月中" %(day))
else:
print("%d 不在月中" %(day))
#2.需求：从控制台输入一个年龄，输出对应的范围
age = int(input("请输入您的年龄："))
if age >=18:
print("===你已成年==")
else:
print("===你是未成年=====")
3 多分支【if-elif-elif…-else】
# chnegji 90 A 80 B 70 C 60 D 不及格
cheng_ji = int(input("请输入一个成绩："))
#0-100
if cheng_ji >=0 and cheng_ji <= 100:
if cheng_ji >= 90:
print("A")
elif cheng_ji >= 80:
print("B")
elif cheng_ji >= 70:
print("C")
elif cheng_ji >= 60:
print("D")
else:
print("不及格")
else:
print("====成绩无效====")
4 三者的区别
多分支：多选一
单分支：要么执行，要么不执行
双分支：二选一
八 运算符和表达式【重点掌握】
1.逻辑运算符
逻辑运算符就是用来进行逻辑运算的，为了和条件运算符结合使用，运算的结果可以作为条件使用【真假】
运算符：and【逻辑与】 or【逻辑或】 not【逻辑非】
2.成员运算符
in :判断一个数据在一个指定容器【可迭代对象】中是否存在，如果存在，则返回True
not in：判断一个数据在一个指定容器【可迭代对象】中是否不存在，如果不存在，则返回True
list1 = [1,2,3]
num = 22
if num in list1:
print("含有")
else:
print("不含有")
print("++++++++++++++++++++++++++")
list2 = [9,8,7,10]
num2 = 99
if num2 not in list2:
print("===不在===")
else:
print("====在里面====")
3.身份运算符
is:判断两个标识符是否引用自同一个实体【实质：判断两个变量的地址是否相同】
is not：判断两个标识符是否引用自不同的的实体
a = 10
b = 10
a = "hello"
b = "hello"
a = True
b = 1
if a is b:
print("a is b")
else:
print("a is not b")
print(id(a))
print(id(b))
print("++++++++++++++=== ==++++++++++++++++")
a = "1"
b = 1
print(a == b)
print(a is b)
print("+++++++++++++++++++++++++")
3.1 简述is和==的区别
is:比较的两个变量的地址
==:比较的是两个变量的值【内容】
九 循环语句之while语句【重点掌握】
1.概念
在满足条件的情况下，反复执行某一段代码，在编程语言中出现的这种现象称为循环，某段被重复执行的代码被称为循环体
2.while语句的使用
2.1基本使用
语法：
while 条件：
循环体
说明：while语句和if语句的区别：在条件成立的前提下，if语句只会执行一次，但是while语句至少执行一次
工作原理：在代码执行的过程中，遇到while语句，首先判断条件是否成立，如果不成立，则直接跳过整个while语句，继续执行后面的代码；如果条件成立，则执行while代码块中的代码，执行完之后再次判断条件是否成立，。。。。如此循环往复，直到条件为假，则整个循环才会结束，机修执行后面的代码
2.1.1 练习1
#循环的初始值
i = 1
while i <= 10:
print("====hello uu=====")
i += 1
print("=====over=====")
2.1.2 练习2 ：完成1-100之间偶数的和
sum = 0#定义一个变量来接收和
i = 1#定义一个循环初始值
while i <= 100:
if i % 2 == 0:
sum += i
i += 1
print("==1-100之间偶数的和==%s" % sum)
2.2else分支
语法：
while 条件：
循环体
else:
语句
注意：else可以省略
sum = 0
i = 1
while i <= 5:
sum += i
i += 1
else:
print(i)
print("=====循环条件不满足了===")
print("====sum=%s" % sum)
2.3 死循环
"""
死循环
"""
while 1:
print("hehe")
2.4 嵌套循环
2.4.1 练习1
while 条件：
while 条件：
执行语句
外循环
wai = 1
while wai <= 3:
nei = 1
while nei <= 3:
print("%s---%s\t" %(wai,nei),end="")
nei += 1
wai += 1
print()
2.4.2 练习2
"""
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
"""
i = 1
while i <= 5:
j = 1
while j <= 5:
print("* ",end="")
j += 1
i += 1
print()
2.4.3 练习3
"""
i j
* * * * * 1 12345
* * * * 2 1234
* * * 3 123
* * 4 12
* 5 1
j = 1 j <= 6-i
"""
i = 1
while i <= 5:
j = 1
while j <= 6-i:
print("* ",end="")
j += 1
i += 1
print()
2.4.4 练习4
"""
i j
*
* *
* * *
* * * *
* * * * *
j<=i
"""
i = 1
while i <= 5:
#完成每一行的内容
j = 1
while j <= i:
print("* ",end="")
j += 1
i += 1#打印完一行就换行
print()#打印完一行就换行
print("+++++++++++++++++++++++++++++++++++++++=")
"""
1
12
123
1234
12345
"""
i = 1
while i <= 5:
j = 1
while j <= i:
print(j,end="")
j += 1
i += 1
print()
"""
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
"""
print("++++++++++++++++++++++++++++++++++++++++++++++++")
i = 1
while i <= 9:
j = 1
while j <= i:
print("%d * %d = %d\t " %(j,i,i*j),end="")
j += 1
i += 1
print()
2.4.5 练习5：三角形
"""
*
* *
* * *
* * * *
* * * * *
*
**
***
****
*****
j>=6-i
"""
i = 1
while i <= 5:
j = 1
while j <= 5:
if j >= 6-i:
print("* ",end="")
else:
print(" ",end="")
j += 1
i += 1
print()
2.4.6 练习6：菱形
"""
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
*
**
***
****
*****
i j
**** 6 >=2
*** 7 >=3
** 8 >=4
* 9 >=5
"""
i = 1
while i <= 9:
if i <= 5:
j = 1
while j <= 5:
if j >= 6 - i:
print("* ",end="")
else:
print(" ",end="")
j += 1
else:
k = 1
while k <= 5:
if k >= i - 4:
print("* ", end="")
else:
print(" ", end="")
k += 1
i += 1
print()
2.4.7 练习7：
"""
1 1 1
2 2 2
3 3 3 3 3
4 4 4
5 5 5
"""
#五行五列 i 1-5 j 1-5
i = 1
while i <= 5:
j = 1
while j <= 5:
if i == 3 or j == 3 or j == 5 or j==1 and (i==1 or i==5) or j==2 and (i==2 or i==4):
print("%d "% i ,end="")
else:
print(" ",end="")
j += 1
i += 1
print()
2.4.8 练习8
求100以内的质数 2----100内循环就是判断当前数字是不是质数
标志位
isZhi
i = 2
while i <= 100:
#定义一个标志位 标识这个数字是不是质数 初始值定义为真
isZhi = True
j = 2
while j < i:
#除以所有小于自己的数字 如果有除尽的 就说明其不是质数
if i % j == 0:#说明除尽了
isZhi = False
break#跳出当前循环 意思是已经不是了就不用继续循环了
j += 1
if isZhi:
print("%d 是质数" % i)
i += 1
2.4.9 练习9
一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。
i = 2
while i <= 1000:
#判断i是不是完数 先要算出一个因子之和
sum = 0
#一个数的因子就是比他小的数可以除尽的数
j = 1
while j < i:
if i % j == 0:
sum += j#如果除尽了 说明是因子 加到因子之和
j += 1
#判断因子之和是不是自己
if i == sum:
print(i,end=",")
i += 1
十 list 列表
列表的元素可以重复
1 列表的定义
list1 = []
print(list1)
print(type(list1))#<class 'list'>
if not list1:
print("===空列表====")
print("++++++++++++++++++++++")
print(len(list1))
2 创建列表
创建列表其实就是定义一个列表类型的变量
语法：
变量名 = 值
列表名 = [数据1，数据2…]
说明：
a.使用[]表示列表
b.列表中存储的数据被称为元素
c.列表中的元素被自动的从头到尾做了编号，编号从0开始，这些编号被称为索引，下标或者角标
d.索引的取值范围：0 ~ 元素的个数 - 1
e.问题：如果超过索引的范围，则会报错【下标越界：IndexError】
2.1 列表的基本操作 — 下标
list1 = [1,2,33,90]
print(list1)
print(len(list1))
print(list1[2])
print(list1[0])
#0 -- len -1
print("==========用while遍历一下这个数组====")
index = 0
while index < len(list1):
print(list1[index],end=",")
index += 1
2.1.2 元素类型
list1 = [1,"hello",9.9,True]
print(list1)
print(list1[3])
i = 0
print("+++++++++++++++++++++++++++=")
while i < len(list1):
print(list1[i],end=",")
i += 1
3.列表的访问
a.获取元素
b.修改元素
list1 = [1,2,3,4]
print(list1)
print(list1[2])
print("++++++ 0 - len-1++++++")
print("======倒叙的获取==========-1 - len====")
print(list1[-1])
print(list1[-len(list1)])
"""
0 -len
1 -len+1
"""
print("======下标越界++++++++++")
#print(list1[10])#IndexError: list index out of range
#print(list1[-10])#IndexError: list index out of range
print(list1)
list1[0] = 11
list1[1] = 22
list1[2] = 33
list1[3] = 44
print(list1)
print("+++++++++++++++++++++++++++")
print(id(list1))
print(id(list1[0]))
print("++++++++++++++++++++++++++++++++++++++++")
list2 = [1,2,3]
list3 = [90,80,70]
print(list2)
print(list3)
list2 = list3
print(list2)
print(list3)
print(id(list2))
print(id(list3))
4.列表的操作
a.列表组合：+
b.列表元素的重复：*
c.判断元素在列表中是否存在：成员运算符
4.1 操作1
list1 = [1,2,3]
list2 = ["张飞","刘备","关羽"]
he = list1 + list2
print(list1)
print(list2)
print(he)
print("++++++++++++++++++++++++++++++")
list3 = list2 * 3
print(list3)
print("+++++++++++++++++++++++++++")
name = "张飞"
if name in list2:
print("有张飞")
else:
print("张飞走了")
name = "曹操"
if name not in list2:
print("没曹操")
else:
print("有曹操")
print("+++++++++++++++++++")
list4 = ["黛玉","宝玉"]
kaobei = list4 * 4
print(list4)
print(kaobei)
4.2 切片(截取)
【面试题：什么是列表切片？请举例说明】
概念：从一个指定的列表中根据具体的条件获取列表中的部分元素，形成一个新的列表
具体的条件：根据区间和步长确定需要获取的元素语法：
列表名[索引] ：获取列表中执行索引对应的元素
列表名[start:end:step]:获取指定区间内的元素
start:表示区间的开始，可以省略，默认为0
end:表示区间的结束，可以省略，默认为最后一个元素的下标
step：表示索引的步长，可以省略，默认为1
4.2.1 正向
list1 = [0,1,2,3,4,5,6,7]
print(list1)
print(list1[3])
print(list1[1:3])
print(list1[3:5])
print(list1[:])
print(list1[:5])
print(list1[4:])
print(list1[2:6])
print("++++++++++++++++++改变步长+++++++++++++++++++++")
print(list1[::])
print(list1[::2])
print(list1[1::2])
print(list1[::3])
print(list1[1:6:2])
4.2.2 反向
step 为正数 意思是从前往后
step是负数 意思是从后往前取
list1 = [0,1,2,3,4,5,6,7]
print(list1)
print("++++++++++++++++++++++++++++++++++++++")
print(list1[::1])
print(list1[::-1])
print("*************************")
print(list1[6:1:1])
print(list1[6:1:-1])
print("++++++++++++++++++++++++++")
print(list1[-1:-4:-1])
print(list1[-6::-1])
print(list1[::-2])
print(list1[-2::-2])
4.2.3 可以使用循环遍历的方式实现切片功能
list1 = [0,1,2,3,4,5,6,7]
print(list1)
print("+++++++++++正向遍历====")
i = 0
while i < len(list1):
print(list1[i],end=",")
i += 1
print()
print("+++++++++++反向遍历====")
i = -1
while i >= -len(list1):
print(list1[i],end=",")
i -= 1
print()
print("+++++跳着取====")
i = 0
while i < len(list1):
print(list1[i],end=",")
i += 2
print()
print()
print("+++++++++++反向遍历跳====")
i = -1
while i >= -len(list1):
print(list1[i],end=",")
i -= 2
print()
4.2.4 练习
list1 = ["宝玉","黛玉","宝钗"]
print(list1)
print("++++++++++++")
print(list1[::])
print(list1[::-1])#倒序取
print(list1[1:2:1])
print(list1[-2:-3:-1])
print(list1[::2])
print(list1[::-2])
"""
逆向
"""
list1 = [1,2,3,4,5]
print(list1)
print("+++++++++++++++++++++++++")
print(list1[4:2:-1])
print(list1[-4:-2:1])
4.2.4
list1 = ["a","b","c","d","e","f"] #0~5 -1~-6
#bcd
print(list1[1:4])
print(list1[-5:-2:1])
#bcdef
print(list1[1:6])
#abcd
print(list1[:4])
# bd
print(list1[1:4:2])
#[]
print(list1[9:5:1])
#[]
#fed
print(list1[:-4:-1])
#[]
#cde
print(list1[2:5:1])
#fedcba
print(list1[::-1])
#abcde
print(list1[:5])
#bcdef
print(list1[1:])
#bdf
print(list1[1::2])
5.列表功能【基础】
5.1 len() 列表的长度
list1 = [2,3,4,5,6]
print(list1)
print(len(list1))
5.2 append() 追加，向列表的末尾追加元素
格式：列表.append(xx),
注意： 使用append向列表中追加元素，一次只能追加一个元素，如果有多个元素，则以容器的方式追加
list1 = [2,3,4,5,6]
list1.append(10)
print(list1)
list1.append("abc")
print(list1)
list1.append([99,88,77])
print(list1)#[2, 3, 4, 5, 6, 10, 'abc', [99, 88, 77]]
5.3 remove() 移除，删除列表中指定元素【操作元素】
格式：列表.remove(xx)
注意：remove一次只能移除一个元素【从左往右进行匹配】
list1 = [2,3,4,5,6]
list1.append(2)
print(list1)
list1.remove(2)
print(list1)
move2 = list1.remove(2)
print(move2)
print(list1)
5.4 pop() 弹出，从列表中删除指定元素
如果不指明索引，则默认删除最后一个元素
pop1 = list1.pop()
print(pop1)
print(list1)
pop2 = list1.pop(4)#4是移除元素的下标
print(pop2)
print(list1)
print("+++++++++++++++++++++++++++++++++++++++++++++++++")
5.5 count() 个数，统计一个元素在列表中出现的次数
list2 = [2,3,2,3,2,3,2,3]
print(list2)
count2 = list2.count(2)
print(count2)
print("============删除所有的2=========")
i = 0
while i < count2:
list2.remove(2)
i +=1
print(list2)
5.6 练习：对一个列表中的元素进行奇偶数分离
#list1 = [32,54,5,4,64,65,100,16,7]----->[偶数] [奇数]
list1 = [32,54,5,4,64,65,100,16,7]
print(list1)
ji_list = []
ou_list = []
i = 0
while i < len(list1):#遍历这个列表
yuansu = list1[i]#获取当前元素
if yuansu % 2 == 0:
ou_list.append(yuansu)
else:
ji_list.append(yuansu)
i += 1
print(ji_list)
print(ou_list)
6.二维列表
6.1 列表的元素还是列表
规则的
[[1 2 3],[4,5,6],[7,8,9]]不规则的
[[1],[2,3],[4,5,6]]
list1 = [[1,2,3],[4,5,6],[7,8,9]]
print(list1)
print(list1[0])
i = 0
while i < len(list1[0]):
print(list1[0][i],end=",")
i += 1
print()
print("+++++++++++++++++")
print(list1[1])
i = 0
while i < len(list1[1]):
print(list1[1][i],end=",")
i += 1
print()
print("++++++++++++++++++++++++++++++")
print(list1[2])
i = 0
while i < len(list1[2]):
print(list1[2][i],end=",")
i += 1
print()
print("++++++++++++++++++++++++++++++++++++++++++++++++++++")
#外循环控制遍历二维 内循环控制遍历内部列表
i = 0
while i < len(list1):#i表示是第几个内部列表
#list1[i] 0 === len-1
j = 0
while j < len(list1[i]):#j表示是内部列表的第几个元素
print(list1[i][j],end=",")
j += 1
i += 1
print()
6.2 二维列表的操作
names = [["悟空","八戒","唐僧"],["宝玉","黛玉"],["宋江","燕青","林冲","武松"]]
print(names)
print(names[2][1])
print(names[1][1])
names[1][0] = "宝钗"
print(names)
print("++++++++++++++++++++++++++++++++++++++++++++")
i = 0
while i < len(names):
#names[i] --- 第几组名字
j = 0
while j < len(names[i]):
print(names[i][j],end=",")
j += 1
i += 1
print()
十一 for循环【重点掌握】
1.定义及基本使用
语法：
for 变量名 in 容器：
循环体
说明：for-in语句专门用来获取容器中的元素，in是成员运算符，在获取元素的过程中同时做了判断
工作原理：for循环用于遍历容器【遍历：依次访问列表中的每一个元素，获取元素值】，按照顺序获取列表中的元素，赋值给变量，再执行语句，如此循环往复，直到列表中的元素全部遍历完毕，整个循环会自动停止
list1 = [1,2,3,4,5]
print(list1)
for ele in list1:
print(ele,end=",")
print("+++++++++++++++++++++++")
list1=["刘备","关羽","曹操"]
for ele in list1:
print(ele,end=",")
2 range()
range(start,end,step)
start:可以省略，默认为0
end：不能省略
step:步长，可以省略，默认为1
2.1 基本用法
range1 = range(10)
print(range1)
for i in range1:
print(i,end=",")
print("+++++++++++++++++++++++++")
range2 = range(1,10)
for i in range2:
print(i,end=",")
print("++++++++++++++++++++++")
range3 = range(1,10,2)
for i in range3:
print(i,end=",")
print("++++++++++++++++++++++++++++")
range4 = range(2,10,2)
for i in range4:
print(i,end=",")
print("++++++++++++1--表示从小到大 -1 表示从大到小++++++++++++++++++++")
for i in range(8,1,-1):
print(i,end=",")
print("++++++++++++++++++++++")
list1 = [90,80,70,60]
for i in range(len(list1)-1,-1,-1):
print(list1[i],end=",")
print("++++++++++++++++++")
for i in range(-1,-len(list1)-1,-1):
print(list1[i],end=",")
2.2 range – list
list1 = [1,2,3,4,5]
# 0 1 2 3 4
range1 = range(len(list1))
for i in range1:
print(i,end=",")
print("++++++++++++++++++++++++++++++")
for i in range(len(list1)):
#下标 i list1[i]
print("第 %d 个是 %s" %(i+1,list1[i]))
2.3 求一个值在列表中的位置
list1 = [11,2,33,90,100,88]
key = 2
for i in range(len(list1)):
if list1[i] == key:
print(i)
2.4 求列表的最大值及其位置
list1 = [9,99,10,20,30,888,90]
print(list1)
max1 = list1[0]
for ele in list1:
if ele > max1:
max1 = ele
print(max1)
print("++++++++++++++++++++++")
for i in range(len(list1)):
if list1[i] == max1:
print(i)
2.5
"""
练习
1.打印数字列表中的偶数元素
2.打印列表中下标为偶数的元素
"""
list1 = [11,2,33,44,900,89,7]
print(list1)
for ele in list1:
if ele % 2 == 0:
print(ele,end=",")
print("++++++++++++++++++++++++++++++++++")
for i in range(0,len(list1),2):
print(list1[i],end=",")
3.遍历列表
3.1 enumerate(list1) : 将一个列表转换成枚举对象
list1 = [1,22,33,90]
for i,ele in enumerate(list1):
print(i,ele,sep="=====")
print("++++++++++++++++++++++++")
for i in range(len(list1)):
print(i,end="------")
print(list1[i])
4.嵌套for循环
4.1 打印正方形和三角形
"""
*****
*****
*****
*****
*****
"""
for i in range(1,6):
for j in range(1,6):
print("*",end="")
print()
print("+++++++++++++++++++")
"""
*
**
***
****
*****
"""
for i in range(1,6):
for j in range(1,i+1):
print("*",end="")
print()
print("++++++++++++++++++++++++++")
for i in range(1,10):
for j in range(1,i+1):
print("%d * %d = %d \t" % (j,i ,i*j),end="")
print()
4.2 打印菱形
"""
七行七列 i j j左 j右
* 1 4 4 4
*** 2 345 3 5
***** 3 23456 2 6
******* 4 1234567 1 7
>=5-i <=i+3
***** 5 23456 2 6
*** 6 345 3 5
* 7 4 4 4
>=i-3 <=11-i
"""
for i in range(1,8):
for j in range(1,8):
if i <= 4:
if j>=5-i and j <=i+3:
print("*",end="")
else:
print(" ",end="")
else:
if j >=i-3 and j <= 11-i:
print("*",end="")
else:
print(" ",end="")
print()
4.3 遍历二维
#1.
list1 = [[1,2,3],[22,33],[99,88,199]]
for ele in list1:
#print(ele)
for ele1 in ele:
print(ele1,end=",")
print()
print("+++++++++++++++++++++++++++++++")
max1 = list1[0][0]
for ele in list1:
for ele1 in ele:
if ele1 > max1:
max1 = ele1
print(max1)
#2.
list1 = [[1,2,3],[4,5,6,656],["aaa",True]]
#遍历这个列表
for ele in list1:
for ele1 in ele:
print(ele1,end=",")
print()
十二 break和continue和pass语句【重点掌握】
注意：break和continue是关键字，可以单独作为一条语句使用
【面试题：说明break和continue的作用，举例说明】
break:直接结束当前循环
continue:结束当前正在执行的循环，继续下一次循环
1 break 语句
#1.
for i in range(5):
if i ==3 :
break
print(i,end=",")
print("++++++++++++++++++++")
#2.应用在死循环
"""
需求：猜数字游戏
计算机随机出一个1~100之间的数由人来猜
计算机根据人猜的结果给出提示：大一点，小一点，猜中了
"""
num = 77
count = 0
while True:
cai_num = int(input("请输入您猜的数字："))
if cai_num > num:
print("大了")
elif cai_num < num:
print("小了")
else:
print("===恭喜你 猜中了")
break
count += 1
if count >= 7:
print("呵呵 game over")
break
2 continue 语句
for i in range(5):
if i==3 :
continue
print(i,end=",")
print("++++++++++++++++++++++++++++")
names = ["曹操","刘备","孙权","赵云","貂蝉"]
print(names)
for ele in names:
if ele == "孙权":
continue
print(ele,end=",")
3 pass 语句
Python中pass语句是空语句，是为了保持程序结构的完整性
pass一般不做任何事情，一般用作占位语句，只是为了防止语法错误，一般使用在if，while,函数，类等代码块中
十三 list功能
1 增加
append：追加，在列表的末尾追加元素
追加单个元素
如果通过append向列表中追加多个元素，则以容器的方式追加，但是，会将整个容器追加进去
extend：扩展，在列表的末尾追加元素
- 追加单个元素
- 多个，可迭代对象：能用for循环遍历的数据类型对应的变量，有
list,tuple.dict,set,str等insert：插入，在列表的指定位置插入指定元素,后面的其他元素向后顺延，语法：列表名.insert(索引，元素)
- 单个
- 多个
1.1 append
list1 = [1,2,3]
print(list1)
list1.append(10)
print(list1)
#list1.append(20,30)#TypeError: append() takes exactly one argument (2 given)
list1.append([20,30])
print(list1)
print("+++++++++++++++++iterable ++list,tuple.dict,set,str等+++++")
1.2 extend 追加
list1 = [1,2,3]
#list1.extend(10)#TypeError: 'int' object is not iterable
list1.extend([10])
print(list1)
list1.extend([100,900,1000])
print(list1)#[1, 2, 3, 10, 100, 900, 1000]
list1.extend("hehe")
print(list1)
1.3 insert
list1 = [1,2,3,4,5]
print(list1)
list1.append(99)
print(list1)
list1.insert(2,22)#2的意思是添加的位置 22 是添加的元素
print(list1)
list1.insert(4,88)
print(list1)
print("+++++++++++++++++")
list1.insert(1,[888,999])
print(list1)
list1.clear()#清空列表内容
print(list1)
2 删除
pop：操作索引，返回被删除的元素
remove：操作元素，remove返回None
clear：清除，将指定的列表清空,可以使用在tuple，dict，set，原列表变成空列表
list1 = [1,2,3,4,5]
#1.pop
pop1 = list1.pop() #移除最后一个元素
print(pop1)
print(list1)
list1.pop(1) #根据下标来删除
print(list1)
#2.remove
list1 = [11, 22, 55, 33, 44]#根据对象值来删除
list1.remove(22)
print(list1)
#3.clear
list1.clear()#清空列表内容
print(list1)
3 修改
reverse、append、切片、sort、
3.1 reverse：反转，将原列表倒序 ； append 添加；切片
list1 = [11,22,33,44]
print(list1)
list1.reverse()#列表发生改变
print(list1)
print("+++++++++++++++++++++++++++++++")
list2 = [11,22,33,44]
print(list2)
list3 = list2[::-1]
print(list3)
print(list2)
print("+++++++++++++++++++++++++++++++")
list4 = []
for i in range(-1,-5,-1):
list4.append(list2[i])
print(list4)
print(list2)
print("+++++++++++++++++++++++++++++++")
list4 = []
for i in range(3,-1,-1):
list4.append(list2[i])
print(list4)
print(list2)
3.2 sort：排序，默认升序
降序，reverse=True
list1 = [22,3,45,9,1]
print(list1)
list1.sort()
print(list1)
#想改变排序规则 使用reverse=True
list1.sort(reverse=True)
print(list1)
#有时候不想使用自然排序
#对于字符串来说自然排序是指字典顺序
names = ["ss","hello","air","uukiller","x","like"]
print(names)
names.sort()
print(names)
#要求以字符串的长度来进行排序
names.sort(key=len)#根据长度的升序排序
print(names)
names.sort(key=len,reverse=True)#key是排序规则 reverse=True=是降序
print(names)
4 查看
len(list)：获取列表的长度
count(元素)：统计一个指定元素在列表中出现的次数
max(list)、min(list)：获取列表中的最值
index(元素),获取指定元素在列表中的位置【索引值】
#1.len:获取列表的长度
list1 = [1,2,34,99,100,999,2,3,2]
print(list1)
print(len(list1))
##2.count：统计一个指定元素在列表中出现的次数
print(list1.count(2))
print("+++++++++++++++++++++++++")
count = list1.count(2)
for i in range(len(list1)):
if list1[i] == 2:
print(i,end=",")
print(count)
print("+++++++++++++++++++++++++++++++")
#3.max、min：获取列表中的最值
print(max(list1))
print(min(list1))
print("+++++++++++++++++++++++++++++++=")
#4.index,获取指定元素在列表中的位置【索引值】
#注意：只返回第一个匹配到的元素的下标
print(list1)
num = 99
print(list1.index(num))
print("++++++")
num = 2
count = list1.count(num)
print(count)
#找一个元素的时候 一个是num 一个是从什么地方开始
index = 0
for i in range(count):#找三次 0 1 2
weizhi = list1.index(num,index)
print("第 %d 个所在位置 %d" % (i+1,weizhi))
index = weizhi + 1
5 copy 拷贝
list1 = [1,2,3]
list2 = list1.copy()#copy出来的地址不同 内容相同
print(list1)
print(list2)
print(id(list2))
print(id(list1))
list1[1] = 99
print(list1)
print(list2)
十四 tuple元组
1.概述
和列表相似，本质上是一种有序的集合
元组和列表的不同之处：
a.表示，list:[] tuple:()
b.列表中的元素可以进行增加和删除的操作【列表是可变的】，但是，元组中的元素不能进行随意的更改【元组是不可变的：一旦被初始化，将不能进行改变】
# 创建元组
list1 = [1,2,2,3]
print(list1)
print(type(list1))
print("+++++++++++++++++++++++++++")
tuple1 = (1,2,2,3)
print(tuple1)
print(type(tuple1))#<class 'tuple'>
tuple2 = (1,"ww",True)
print(tuple2)
tuple3 = (10)
print(type(tuple3))#<class 'int'>
tuple4 = (10,)
print(type(tuple4))#<class 'tuple'>
2.访问元组，元组不可变
【面试题：list和tuple的区别】
- 1.list是可变的【其中的元素可以增加，删除或者修改】，tuple是不可变的，在多线程的环境下，更需要的是不可变的数据类型，可以避免由于多个线程同时访问同一个数据造成的数据混乱，使用元组比使用列表安全
- 2.元组在创建时间和占用的空间上优化于列表
tuple1 = (1,2,3,4)
print(tuple1)
print(tuple1[1])
print("++++++++++++++++++++++++")
for ele in tuple1:
print(ele,end=",")
print("")
#tuple1[1] = 99#TypeError: 'tuple' object does not support item assignment
3.元组功能
len,max,min,count
tuple1 = (1,2,3,499,3,3)
print(tuple1)
print(len(tuple1))#长度
print(max(tuple1))#最大值
print(min(tuple1))#最小值
print(tuple1.count(3))#3有几个
print("++++++++++++列表和元组的相互转化++++++++++++++++++++++++=")
list1 = list(tuple1)
print(list1)
list1[3] = 888
print(list1)
tuple1 = tuple(list1)
print(tuple1)
4.元组的遍历
"""
四种遍历方式
"""
#下标遍历
tuple1 = (1,2,99,90,7)
i = 0
while i < len(tuple1):
print(tuple1[i],end=",")
i += 1
print()
#for in
for ele in tuple1:
print(ele,end=",")
print()
#for i 可以获取到下标
for i in range(len(tuple1)):
print(tuple1[i],end=",")
print()
#枚举
for i,value in enumerate(tuple1):
print(i,end="----")
print(value)
5.二维元组
"""
元组的元素还是元组
"""
names = (("aa","cc","qq"),("killer","uu"),("pike","like"))
print(names)
print(names[1][0])
print("++++++++++++++++++++++++++++")
for ele in names:
#ele--第几个
for ele1 in ele:
print(ele1,end=",")
print()
十五、dict 字典
key的特性
- a.字典中的key是不允许重复的【key是唯一的】
要求唯一,不可变的- b.key的类型必须是不可变的
- 可变的：list,dict,set,不能作为字典中key [1,2,3] [1,2,3]
- 不可变：tuple,str,int,float，可以充当字典中的key (1,2,3) “hello” 10 9.9
1.字典的创建
#字典的创建
dict1 = {}
print(dict1)
print(type(dict1))#<class 'dict'>
dict1 = {"qq":90,"ww":99,"ss":9,"uu":88}
print(dict1)
print(len(dict1))#4---有四对值
print("++++++++++++++++++++++++++++++")
#dict1 = {[1,2]:90,[3,4]:80}#TypeError: unhashable type: 'list'
#hash --- 哈希值---地址 哈希地址 可变类型 list 不能作为字典的键
#print(dict1)
2.字典的使用
获取对应的value
- 字典名[key],通过指定的key获取对应的value
- 字典名.get(key)
pop(key) 通过键删除键值对
"""
字典的使用
键值对 所有的操作都是以键为标准
"""
dict1 = {"刘备":90,"赵云":80}
print(dict1)
#语法：字典名[key],通过指定的key获取对应的value
name= "刘备"
score = dict1.get(name)#根据键来获取值
print(score)
print("++++++++++++++++++++++++++++++++")
print(dict1["赵云"])
print(dict1["刘备"])
#print(dict1["刘禅"])
print("++++++++++++++++++++++++判断含有不含有键+++++++++++++++++++++++++")
print(dict1.get("赵赵"))
name = "赵云"
if name in dict1:
print(dict1.get(name))
print("++++++++++++++++++++++字典的修改++++++++++++++++++++++")
print(dict1)
dict1["赵云"] = 98#根据键来修改值
print(dict1)
dict1["曹操"] = 88#如果没有 就新添加
print(dict1)
print("++++++++++++=字典的删除++++++++++++++++++++++++++++==")
#3.删除
#pop(key)，类似于list中的pop(index)
print(dict1)
shanchu = dict1.pop("刘备")#pop返回值是被删除的值 删除的是键值对整体
print(shanchu)
print(dict1)
3.dict(),字典的多种创建方式
类似于list(),tuple（）,将其他的数据类型转换为字典类型
zip:映射
##a。key=value关键字
dict1 = dict(a=1,b=2,c=90)
print(dict1)
#b.zip:映射
dict1 = dict(zip(['a','b','c'],[90,80,70]))#对应位置映射
print(dict1)
print("+++++++++++++++++++++")
name_list = ["黛玉","宝玉","晴雯","袭人"]
score_list = [99,89,88,90]
dict1 = dict(zip(name_list,score_list))
print(dict1)
print("++++++++++++++++++++++++++")
dict1 = dict([('qq',90),('ww',100),('ss',80)])
print(dict1)
print("++++++++++++++++++++++")
dict1 = {}
dict1['qq'] = 100
dict1['ww'] = 90
dict1['xx'] = 80
print(dict1)
print("_________________________")
name_list = ["黛玉","宝玉","晴雯","袭人"]
score_list = [99,89,88,90]
score_dict = {}
for i in range(len(name_list)):#0 1 2 3
#i 将namelist的值作为键 将scorelist的值作为字典的值
score_dict[name_list[i]] = score_list[i]
print(score_dict)
4.字典的增删改查
dict1 = {"qq":90,"uu":80,"vv":70}
print(dict1)
dict1["ds"] = 80
print(dict1)
qq_zhi = dict1.pop("qq")
print(qq_zhi)
print(dict1)
dict1["uu"] = 100
print(dict1)
print("++++++++++++++++++++")
print(dict1["uu"])
print(dict1.get("uu"))
5.字典的遍历
字典名.keys()–获取指定字典中所有的key
字典名.values() – 获取字典中所有的value
字典名.itmes() — 用在for循环中，同时获取键和值
dict1 = {"qq":20,"ww":26,"uu":19}
print(dict1)
print("++++++++++#1.只获取key ++++++++++++++++")
for key in dict1:
print(key,dict1.get(key))
print("++++++++++#2. 只获取key ,keys()获取指定字典中所有的key++++++++++++++")
keys = dict1.keys()
print(keys)
for key in dict1.keys():
print(key, dict1.get(key))
print("+++++++++++#3.只获取value，values()获取指定字典中所有的value====")
values = dict1.values()#获取字典中所有的值
for value in values:
print(value)
print("++++++++++++++++++++")
for i,key in enumerate(dict1):
print(i,key,dict1.get(key))
print("++++++++++++++++++++++++++++++++++++")
for key,value in dict1.items():
print(key,value)
6.字典的练习
6.1 练习1
已知列表list1 = [0,1,2,3], list2 = [‘a’,‘b’,‘c’,‘d’]，将list1中的元素作为key，list2中的元素作为value生成一个字典{0：‘a’,1:‘b’…}
list1 = [0,1,2,3]
list2 = ['a','b','c','d']
print(list1)
print(list2)
print("=====通过映射方法======")
dict1 = dict(zip(list1,list2))
print(dict1)
print("=====通过遍历赋值的方式====")
dict2 = {}
for i in range(len(list2)):
key = list1[i]
value = list2[i]
dict2[key] = value
print(dict2)
6.2 练习2
已知任意一个字典，编写代码，交换key和value
举例{0: ‘a’, 1: ‘b’, 2: ‘c’, 3: ‘d’}-----> {‘a’:0,“b”:1…}
dict1 = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
dict2 = {}
print(dict1)
print("+++++++++++++++++++++++++")
for key in dict1:
#根据key来的得到value
value = dict1.get(key)
#将键作为value 将值作为key
dict2[value] = key
print(dict2)
print("+++++++++++++++++++++++++++++++++++++++++==")
dict3 = {}
for key,value in dict1.items():
dict3[value] = key
print(dict3)
6.3 练习3
对一个数字列表进行奇偶数分离，结果如下
举例：[2,3,4,5,6]------> {“偶数”:[2,4,6],“奇数”：[3,5]}
list1 = [2,3,4,5,6]
print(list1)
ji_list = []
ou_list = []
for ele in list1:
if ele % 2 == 0:
ou_list.append(ele)
else:
ji_list.append(ele)
print(ou_list)
print(ji_list)
dict1 = {}
dict1["偶数"] = ou_list
dict1["奇数"] = ji_list
print(dict1)
print("++++++++++++++++++++++++++")
for key,value in dict1.items():
print(key,value)
6.4 练习4
随机生成10个整数，范围为1~100之间，统计每个数出现的次数
# 方法1
# 键是数字本身 值是数字出现的次数
nums = [1,22,22,22,1,3,1,3,3,22]
print(nums)
dict1 = {}#键是数字本身 值是数字出现的次数
# 1 1 1 2
#先遍历这个list
for ele in nums:
#ele ---判断这个ele在字典的key中是否出现过
#一种是存在的 只需要次数加加
#一种不存在 只需要存出现一次
if ele in dict1:#后面都是执行上面
count = dict1.get(ele)#获取之前这个数字的出现次数
count += 1
dict1[ele] = count
else:#第一次出现 走下面
dict1[ele] = 1
print(dict1)
# 方法2
nums = [1,22,22,22,1,3,1,3,3,22]
print(nums)
dict1 = {}#键是数字本身 值是数字出现的次数
#首先遍历这个列表
for ele in nums:
if ele in dict1:
continue
#要知道这个数字出现了几次
count = nums.count(ele)
dict1[ele] = count
print(dict1)
十六、set 集合
1. 元素的增加
add —整体添加 要求是必须是不可变类型
update 打碎添加 要求必须是可迭代类型
#add ---整体添加 要求是必须是不可变类型
set1 = {1,2,3}
print(set1)
set1.add(100)
print(set1)
set1.add("hello")
print(set1)
#set1.add([19,28])#TypeError: unhashable type: 'list'
set1.add((19,28))
print(set1)
#update 打碎添加 要求必须是可迭代类型
set1.update([18,19])
print(set1)
set1.update((88,99))
print(set1)
set1.update("hehe")
print(set1)
2.元素的删除
pop删除集合在内存中存储之后的第一个元素
remove(对象）
set1 = {1,2,3,44,90}
print(set1)
pop1 = set1.pop()
print(pop1)
print(set1)
pop1 = set1.pop()
print(pop1)
print(set1)
##2.remove remove(对象）
move1 = set1.remove(44)
print(move1)
print(set1)
if 44 in set1:
set1.remove(44)
set1.discard(44)
#print(set1[2])#TypeError: 'set' object does not support indexing
#unhashable ---- (1,2,3) int float str
#list dict set
#iterable ---- list tuple set dict str
3.集合的遍历
set1 = {1,2,3,4,99}
print(set1)
for ele in set1:
print(ele,end=",")
print("+++++++++++++++++++++++++++++++++")
for i,ele in enumerate(set1):
print(i,ele)
4.集合之间的运算
a & b:交集，集合a和集合b中都包含的元素
a | b:并集，集合a或者集合b中包含的元素
a ^ b:不同时包含集合a和集合b中的元素
a - b:差集，集合a中包含而集合b中不包含的元素
set1 = {1,2,3,5}
set2 = {2,5,8,10}
print(set1)
print(set2)
print("====a & b:交集，集合a和集合b中都包含的元素===")
jiaoji = set1 & set2
print(jiaoji)
print("===a | b:并集，集合a或者集合b中包含的元素======")
bing = set1 | set2
print(bing)
print("===a ^ b:不同时包含集合a和集合b中的元素=====")
yihuo = set1 ^ set2
print(yihuo)
print("++++++++++#1.a - b:差集，集合a中包含而集合b中不包含的元素++++")
cha = set1 - set2
print(cha)
5.集合功能
union:作用和|相同，求并集
intersection,作用和&相同，求交集
difference:作用和-相同，求差集
set1 = {1,2,3,5}
set2 = {2,5,8,10}
print(set1)
print(set2)
print("=====#union:作用和|相同，求并集++++++++++=")
bingji = set1.union(set2)
print(bingji)
print("+++++++intersection,作用和&相同，求交集+++++++++++")
jiao = set1.intersection(set2)
print(jiao)
print("+++++#6.difference:作用和-相同，求差集===")
cha = set1.difference(set2)
print(cha)
set1 = {1,2,3,4}
print(len(set1))
set1.clear()
print(set1)
set1 = {22,33,44}
print(set1)
set2 = set1.copy()
print(set2)
print(id(set1))
print(id(set2))
6.练习
需求：去除列表中的重复元素
# 方式1
ist1 = [5,454,56,56,5]
print(list1)
list2 = []
for ele in list1:
if ele not in list2:
list2.append(ele)
print(list2)
print("++++++++++++++++++++++")
# 方式2
set1 = set(list1)
print(set1)
list2 = list(set1)
print(list2)
7.list,tuple,dict和set之间的区别【面试题】
相同点：
- a.四者都是数据结构
- b.四者都是可迭代对象
- c.四者都可以存储不同类型的数据
- d.可以通过系统的list(),tuple(),dict(),set()进行相互转换
不同点：
- a.表示形式：list:[] tuple:() dict和set；{}
- a.dict中存储的键值对，list,tuple和set直接存储元素
- b.dict中的key不能是可变的数据类型【list,dict,set】
- c.tuple是不可变的，list,dict,set都是可变的数据类型，可以进行增加和删除的操作
- d.dict查找和插入的速度较快，不会随着key-value的增多而变慢，但是，list的查找速度会随着元素的增多而变慢【原因：每次查找都是从头开始进行遍历的】
- e.dict相比较list会占用更多的内存空间，而list只相当于存储了dict中的key或者value，并且在内存中数据是紧密排列的，可以节约大量的内存
十七、简单算法
1.求数字列表中的最大值
list1 = [3,32,54,54,5]
print(list1)
print(max(list1))
max1 = list1[0]
for ele in list1:
if ele > max1:
max1 = ele
print(max1)
2.求数字列表中的最大值和位置
list1 = [3,32,54,54,5]
print(list1)
max1 = list1[0]
max_index = 0
for i in range(len(list1)):
if list1[i] > max1:
max1 = list1[i]
max_index = i
print(max1,max_index)
3.交换列表的给定两个位置的值
list1 = [1,22,33,44,90,100]
num1 = 0
num2 = 3
print(list1)
temp = list1[num1]
list1[num1] = list1[num2]
list1[num2] = temp
print(list1)
4.冒泡排序
相邻元素比较 大的放后面,一般是一个循环嵌套来完成
外循环控制比较轮次–内循环控制比较过程
list1 = [23,3,89,20,9]
print(list1)
#外循环控制比较轮次 比较的轮次 比如有len个数字 因为每次淘汰一个，所有需要len-1次循环
for i in range(len(list1)-1):
#内循环控制的是比较的过程 从左向右逐一比较
#左边界 0 右边界 因为每一轮都淘汰一个元素 所以每次右边界都会缩小一个 所以使用-i来表示这种缩减
for j in range(len(list1)-1-i):
# j--当前元素 与其相邻后面的一个值比较 所以比较对象 j+1
#j j+1 比 如果前面大 就要换
if list1[j] > list1[j+1]:
#换
temp = list1[j]
list1[j] = list1[j+1]
list1[j+1] = temp
print(list1)
print(list1)
5.选择排序
选定一个位置 将最小值换到这个位置上
外循环控制选定位置 — 内循环控制比较过程
list1 = [23,3,89,20,9]
print(list1)
#外循环控制选定位置
for i in range(len(list1)-1):# 0 1 2 3
#内循环 选定位置后面的所有值 所以左边界是i+1 右边界到len-1
for j in range(i+1,len(list1)):
#j---i后面的所有值
#比较的就是i 和 j
#如果选定位置值比后面的值大 就换
if list1[i] > list1[j]:
temp = list1[i]
list1[i] = list1[j]
list1[j] = temp
print(list1)
5.1 选择排序的优化
尽量减少堆操作 也就是交换的次数 — 可以提高代码的执行效率
list1 = [99,87,69,20,9]
print(list1)
#外循环控制选定的位置
for i in range(len(list1)-1):
#i表示的就是选定位置
#定义一个变量 记录最小值的位置
min_index = i#默认最小值在选定位置 如果在选定位置 就不会换
#内循环控制比较过程 目的寻找最小值
for j in range(i+1,len(list1)):
#j min_index
if list1[j] < list1[min_index]:
min_index = j
#判断需不需要换 如果最小值就在选定位置 就不换
if min_index != i:
temp = list1[i]
list1[i] = list1[min_index]
list1[min_index] = temp
print(list1)
6.在一个列表中找一个元素所在的位置
list1 = [3,5,45,4,4,100]
print(list1)
key = 450
for i in range(len(list1)):
if list1[i] == key:
print(i)
break
else:
print("没有这个元素")
7.二分查找
前提 列表有序
找到中间值 与要找的元素比较 通过比较 缩小查找范围 每次可以淘汰掉一半的元素，所以查询效率很高
list1 = [2,9,20,30,48,78,90,120,390,500]
print(list1)
key = 390
print(key)
#首先定义最小和最大位置
min = 0
max = len(list1)-1
#中间值的默认值
mid = 0
while min <= max:#左边界小于右边界才有可能找到
#每次查找之前 重新计算中间值的位置
mid = (min + max) // 2
#print("min--%d max --%d mid---%d" %(min,max,mid))
#使用中间值与要找的值进行比较 比较结果有三种
#中间值大于要找的值 这时候说明值在左半边 缩小右边界 max=mid-1
#中间值小于要找的值 这时候说明值在右半边 放大左边界 min=mid+1
#等于 说明找到了 结束
if list1[mid] > key:
max = mid - 1
elif list1[mid] < key:
min = mid + 1
else:
print("找到了 %d " % mid)
break
else:
print("没有这个元素")
十八、number 数字
1.布尔型和空值
注意：布尔值相当于数字，True代表1，False代表0，布尔值可以和数字之间进行数学运算
作用：用于if语句或者while语句作为条件
空值是一种特殊的数据类型，当一个变量不确定该指向哪个实体的时候，则可以给它赋值为None，一般用于变量的初始值或者用于重置变量
print(True + 2)
print(False + 2)
num1 = num2 = num3 = 9#=右结合的 +=
print(num1)
print(num2)
print(num3)
print("+++++++++++++++++++++")
num1,num2 = 2,30
print(num1)
print(num2)
2.【面试题：交换两个变量的值，但是不允许出现第三方变量】
a = 10
b = 8
print(a,b)
print("++++++++++++++++#方式一：定义一个中间变量+++++++++++++++++++++")
temp = a
a = b
b = temp
print(a,b)
print("++++++++++++++++#方式一：Python特有的语法+++++++++++++++++++++")
a = 10
b = 8
print(a,b)
a,b=b,a
print(a,b)
print("++++++++++++++++#方式一：加减法+++++++++++++++++++++")
a = 10
b = 8
print(a,b)
a = a + b# b没变 a便成了两个数之和 a+b a = 10 + 8 =18 b = 8
b = a - b# a没变 a+b b变了 b变成了a a=18 b=8 a-b = 10 b=a
a = a - b# a变了 变成了 b还是a a=18 b=10 a-b = 8 a=b
print(a,b)
print("======#方式四：异或结论：一个数异或另一个数两次，结果为该数本身====")
a = 10
b = 8
print(a,b)
a = a ^ b # b 没变 a--a异或b的结果 a=2
b = a ^ b # a 不变 a = 2 b变了 2 ^ 8 --- 10 b变成a ^ b ^ b a
a = a ^ b # b 没变 是a a 2--a^b b^a b^a^a b 所以是将b赋值给了a
# 0000 1010 --- 10
# 0000 1000 --- 8
# 0000 0010 --- 2
# 0000 1000 --- 8
# 0000 1010 --- 10
print(a,b)
3.math模块的常用方法
1.abs(),求绝对值
2.max/min():求最值
3.pow(),求幂
4.round():求浮点数四舍五入值,
- 如果省略n，则表示对一个浮点数进行取整，但是会进行四舍五入
- 如果不省略n，则表示保留小数点后n位，但是会进行四舍五入
5.sum(容器)，将容器中的元素进行求和
6.ceil(),向上取整
7.floor()，向下取整
8.sqrt() :求算术平方根，结果为浮点型
9.modf() 分离整数部分和小数部分
10.log(),返回自然对数
#import 导入
import math
print("========#1.abs(),求绝对值==========")
print(abs(9))
print(abs(-9))
print("+++++#2.max/min():求最值=======")
print(max([10,9,29]))
print(min([10,9,2]))
print("+++++=#3.pow(),求幂+++++++")
print(pow(2,3))
print(2 ** 3)
print("++++++++++++++求浮点数四舍五入值+++++++++++++")
"""
round():求浮点数四舍五入值 *****
#round(m,n),如果省略n，则表示对一个浮点数进行取整，但是会进行四舍五入
#如果不省略n，则表示保留小数点后n位，但是会进行四舍五入
"""
print(round(9.99))
print(round(9.93,1))
print(round(4.55,1))
print(round(-4.6))
print("+++++#5.sum(容器)，将容器中的元素进行求和+++++++")
print(sum([90,10,80]))
print(sum([1,2,3],3))
print("++++++++进一法====ceil(),向上取整 ====")
print(math.ceil(9.001))
print("++++++++舍一法+++++++++++floor()，向下取整+++++++++++++")
print(math.floor(9.999))
print("++++sqrt() :求算术平方根，结果为浮点型++++")
print(math.sqrt(9))
print(math.sqrt(8))
print("++++modf() 分离整数部分和小数部分===")
print(math.modf(19.29))
print("++++log(),返回自然对数====")
print(math.log(100))
print(math.e)
print(math.pi)
print(math.log10(100))
4.random 随机数
import random
print("++++++++=#1.choice 在一个列表中随机选一个 *****=====")
list1 = [1,20,900,80,30]
for i in range(5):
print(random.choice(list1),end=",")
print("====range(start,end,step),整数,包头不包尾=====")
for i in range(10):
print(random.choice(range(1,101)),end=",")
print("====随机的奇数====")
for i in range(10):
print(random.choice(range(1,101,2)),end=",")
print("====取随机字符===")
for i in range(10):
print(random.choice("killer"),end=",")
print("===取随机整数=====")
for i in range(10):
print(random.randint(10,20),end=",")
print("====取随机整数====")
for i in range(10):
print(random.randrange(1,101,2),end=",")
for i in range(10):
print(random.random(),end=",")#random是一个0-1之间的一个随机值
##需求：获取20`100之间的任意随机数
print()
for i in range(10):
print(int(random.random() * 80 +20),end=",")
5.shuffle:对列表中的元素进行随机排序
import random
list1 = ["东","西","南","北","中","发","白板","幺鸡","一万","一筒","九条","九万","九筒"]
lista = []
listb = []
listc = []
listd = []
for i in range(10):
random.shuffle(list1)
print(list1)
lista = list1[0:3]
listb = list1[3:6]
listc = list1[6:9]
listd = list1[9:12]
print(lista)
print(listb)
print(listc)
print(listd)
十九、str 字符串
\n:换行 \t:制表符
r"xxx"；当一个字符串中出现了多个需要转义的字符，则通过r""进行声明,一般应用在路径或者正则表达式
- print(r"C:\Users\Administrator\Desktop\XA-Python1905\Day7\视频")
1.字符串的创建
str1 = "uu"
print(str1)
print(id(str1))
str2 = "uu"
print(id(str2))
str3 = 'uu is comming ' \
'killer is running'
print(str3)
str4 = """
uu
kk
ok
"""
print(str4)
str5 = "aa\nbb\ncc"
print(str5)
str7 = "aa\tbb\tcc"
print(str7)
str = "A"
2.字符串之间的运算
但凡涉及到对字符串中的字符的改变，都是生成了一个新的字符串【字符串是不可变的】
print("======#1.+:拼接===")
str1 = "like "
str2 = "uu"
print(str1+str2)
str3 = "%s---%s" %("go ","home")
print(str3)
print("==========join====")
#用连接符连接字符串
jieguo = " like ".join(["u","her"])
print(jieguo)
print("===使用索引来获取字符串的字符====")
str1 = "today"
print(str1[3])
print("===判断一个字符串中是否含有某个子串===")
str1 = " good good study "
zichuan = "good1"
print(zichuan in str1)
print("========使用切片来获取字符串的一部分=======")
str1 = "张飞去找关羽关羽不在"
print(str1)
print(str1[2:6])
print(str1[6:])
print(str1[-1:-5:-1])
3.字符串的遍历
str1 = "曹操病了华佗来了"
print(str1)
for ele in str1:
print(ele,end=",")
print("+++++++++++++++++++")
#下标遍历
for i in range(len(str1)):
print(str1[i],end=",")
print("++++++++++++++++++++++++")
for i,s in enumerate(str1):
print(i,s)
4.查找
find():从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的下标，如果查找不到则返回-1
rfind():从右往左进行检索，如果查找不到则返回-1
index()：从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的下标，如果查找不到则会报错
rindex()：从右往左进行检索，如果查找不到则会报错
str1 = "关羽托梦给曹操，曹操感觉很不好"
print(str1)
zichuan = "曹操"
print(str1.find(zichuan))
print(str1.find(zichuan,6))
print(str1.find(zichuan,6,10))
print("++++++++++++rfind 从右向左找 下标还是真的下标+++++++++++++++++")
print(str1.rfind(zichuan))
print(str1.rfind(zichuan,7))
print(str1.rfind(zichuan,1,7))
print(str1.find("张飞"))
print("+++++++++++++++++++++")
print(str1.index(zichuan))
print(str1.index(zichuan,6))
#print(str1.index(zichuan,10))
5.转换
int():将字符串转换为整型
eval():将str转换为有效的表达式
upper():小写----》大写，如：Hello----->HELLO
lower()：大写----》小写
swapcase():小写----》大写,大写----》小写,如：Hello----->hELLO
title():每个单词的首字母大写，其他全部小写
capitalize():首单词的首字母大写，其他全部小写
chr()
ord()
print("======字符串的转换方法=====")
str1 = "99"
print(int(str1))
str1 = "2*3+2**3"
print(eval(str1))
print("++++++++++++++++++++++++++++")
str1 = "Heloo Uu"
print(str1)
print(str1.upper())#转成全大写
print(str1.lower())#转成小写
print(str1.swapcase())
str1 ="today is a good day"
print(str1)
print(str1.title())
print(str1.capitalize())
print("++++++++++++++++++++++++")
print(chr(97))
print(ord("A"))
str1 ="today is a good day"
print("+++++++++++++++++++++++++++++++++++++++=")
list1 = list(str1)
print(list1)
list2 = []
for ele in list1:
mazhi = ord(ele)
list2.append(mazhi)
print(list2)
chazhi = ord("a")-ord("A")
print(chazhi)
for i in range(len(list2)):
zhi = list2[i]
zhi = zhi - 32
list2[i] = zhi
print(list2)
for i in range(len(list2)):
zhi = list2[i]
zifu = chr(zhi)
list2[i] = zifu
print(list2)
str2 = ""
for ele in list2:
str2 += ele
print(str2)
6.填充和提取
"""
填充和提取
center(width[,fillchar]):用fillchar填充指定的字符串,填充之后字符串的长度为width，原字符串居中显示，
如：hello---->center(15,"*")------》*****hello**** ***
ljust(width[,fillchar]):用fillchar填充指定的字符串,填充之后字符串的长度为width，原字符串居左显示,
如：hello---->ljust(15,"*")------》hello*********
rjust(width[,fillchar]):用fillchar填充指定的字符串,填充之后字符串的长度为width，原字符串居右显示,
如：hello---->rjust(15,"*")------》*********hello
zfill(width)：原字符串居右显示，剩余的字符默认为0填充，如：hello---->zfill(15)------》000000000hello
"""
str1 = "hello"
str2 = str1.center(100,"*")
print(str2)
str3 = str1.ljust(100,"*")
print(str3)
str4 = str1.rjust(100,"*")
print(str4)
print(str1.zfill(100))
print("")
"""
strip():去除一个字符串两端的指定字符，如：*****he****llo****----》strip("*")----->he****llo ***
lstrip():去除一个字符串左边的指定字符
rstrip():去除一个字符串右边的指定字符
"""
print(str2)
print(str2.strip("*"))
print(str2.lstrip("*"))
print(str2.rstrip("*"))
7.替换
"""
##### 替换
> replace(old,new):将原字符串中的old替换为new ***
> 映射替换
> maketrans():创建一个映射表
> translate():根据映射表将指定字符串中的自定字符替换为映射表中对应的字符
"""
str1 = "关羽喜欢张飞"
print(str1)
print(str1.replace("喜欢","讨厌"))
print("+++++++++++++++++++++++++++++++++++++++++++=")
str1 = "uu is comming"
print(str1)
make1 = str1.maketrans({"u":"w","c":"g"})#第一个方法给一个映射表
str2 = str1.translate(make1)#根据映射表开替换字符串内容
print(str2)
8.分割和合并
"""
##### 分割和合并 ***
> join():合并，使用指定的子字符串将列表中的元素连接【列表-----》字符串】str()
> split():分割，使用指定的子字符串将原字符串进行分割，得到一个列表【字符串----》列表】list()
"""
str1 = "曹操"
str2 = "关羽"
print("怕".join([str1,str2]))
str1 = "刘备+++关羽+++张飞"
names = str1.split("+++")
print(names)
for ele in names:
print(ele,end=",")
9.判断
"""
##### 判断
> isalpha():一个字符串非空并字符全部是字母才返回True
> isalnum:一个字符串非空并字符全部是字母或者数字才返回True
> isupper/islower/istitle:和upper,lower和title有关
> isdigit()/isdecimal():一个字符串非空并字符全部是数字才返回True ***
> startswith():判断字符串的前缀【判断一个字符串是否是以指定子字符串开头的】 ***
> endswith()：判断字符串的后缀【判断一个字符串是否是以指定子字符串结尾的】 ***
"""
str1 = "sks1ksk"
print(str1)
print(str1.isalpha())#判断全字母
print(str1.isalnum())#判断字母加数字
print("UK".isupper())
print("ss".islower())
print("Killer Uk".istitle())#判断title
print("12a2".isdigit())#判断全数字
print("123".isdecimal())#判断全数字
print("java is uu".startswith("java"))
print("python is kk".endswith("kk"))
print("+++++++++++++++++++++++++++++++++++++++++++++++")
file_lists=["qq.png","kk.java","qquu.py","qqkiller.py"]
for ele in file_lists:
if ele.startswith("qq"):
print(ele)
print("+++++++++++++++++++++++++++++++++")
for ele in file_lists:
if ele.endswith("py"):
print(ele)
10.编解码
"""
##### 编解码
> encode():编码，将字符串转化为字节类型的过程【str--->bytes】 ***
> decode()：解码。将字节类型转换为字符串的过程【bytes---->str】 ***
"""
str1 = "killer"
print(str1)
byte1 = str1.encode()
print(byte1)
print("++++++++++++++++++++++++")
str2 = byte1.decode()
print(str2)
print("+++++++++++++++++++++++++++")
byte2 = str1.encode(encoding="utf8")
print(byte2)
str3 = byte2.decode(encoding="utf8")
print(str3)
11.练习
11.1 练习1
"""
1.写代码，有如下变量，请按照要求实现每个功能
name = "gouguoQ "
a.移除name变量对应值的两边的空格，并输出移除后的内容
b.判断name变量对应的值是否以"go"开头，并输出结果
c.判断name变量对应的值是否以"Q"结尾，并输出结果
d.将name变量对应的值中的"o"，替换为"p"，并输出结果
e.将name变量对应的值根据"o"分割，并输出结果
g.将name变量对应的值变大写，并输出结果
h.将name变量对-应的值变成小写，并输出结果
i.请输出name变量对应的值的第二个字符
j.请输出name变量对应的值的前三个字符
k.请输出name变量对应值的后2个字符
l.请输出name变量中的值"Q的索引的位置
m.获取子序列，仅不包含最后一个字符，如：woaini则获取woain root则获取roo
n.利用下划线将列表li = ['gou', 'guo', 'qi']的每一个元素拼接成字符串gou_guo_qi
"""
name = "gouguoQ "
print(name)
print(name.rstrip(" "))
print(name.startswith("go"))
print(name.endswith("Q"))
print(name.replace("o","p"))
print(name.split("o"))
print(name.upper())
print(name.lower())
print(name[1])
print(name[:3])
print(name[len(name)-2:len(name)])
print(name.find("Q"))
print(name[:len(name)-1])
li = ['gou', 'guo', 'qi']
print("_".join(li))
11.2 练习2
"""
#3.实现一个整数加法计算器,例如：从控制台输入 3 + 4，最后输出7
#方式一:int(),split()
"""
print("====使用eval====")
str1 = input("请输入您的加法算式：")
jieguo = eval(str1)
print(jieguo)
print("++++++++++++++++++++++++++++++++")
str1 = input("请输入您的加法算式：")
num_list = str1.split("+")
num1 = int(num_list[0])
num2 = int(num_list[1])
jieguo2 = num2+num1
print(jieguo2)
11.3 练习3
"""
#4.统计用户输入的内容中有几个数字，几个字母？
#isdigit；数字 isalpha:字母
"""
str1 = input("请输入一个字符串：")
#遍历输入的字符串 判断每个字符是数字还是字母
count_num = 0
count_zimu = 0
for ele in str1:
if ele.isdigit():
count_num += 1
elif ele.isalpha():
count_zimu += 1
else:
pass
print("几个数字？%d 几个字母 %d" % (count_num,count_zimu))
11.4 练习4
"""
#5.编写敏感词语过滤程序，提示用户输入内容，如果用户输入的内容中包含特殊的字符，如山寨,水货，则将内容替换为*****
#replace find/index和in
"""
str1 = input("请输入您的评价：")
print(str1)
str2 = str1.replace("山寨","精品")
str3 = str2.replace("水货","正品")
print(str3)
11.5 练习5
"""
#6.制作表格
#循环提示用户输入：用户名、密码、邮箱（要求用户输入的长度不能超过20个字符，如果超过则只有前20个字符有效），
# 如果用户输入q或者Q表示不再继续输入，将用户的内容一表格形式打印
#方式一：%
"""
while True:
uname = input("请输入用户名：")
upw = input("请输入密码：")
uemail = input("请输入邮箱：")
list1 = ["q","Q"]
if uname in list1 or upw in list1 or uemail in list1:
print("=====game over===")
break
str1 = "用户名：%s\t 密码：%s \t 邮箱：%s\n" % (uname,upw,uemail)
print(str1)
11.6 练习6
"""
format 格式化
"""
str1 = "{}--{}--{}".format("qq","ww","cc")
print(str1)
11.7 练习7
"""
#7.从控制台输入一个表示时分秒时间的字符串，格式为：xx：xx:xx,获取该时间的下一秒
"""
time = input("请输入时间：格式是 xx:xx:xx")
#16:21:30
#11:59:59
#10:59:59
#10:20:59
#10:10:10
#先分隔出数字
time_list = time.split(":")
hour = int(time_list[0])
min = int(time_list[1])
sec = int(time_list[2])
if hour == 11 and min == 59 and sec == 59:
print("00:00:00")
elif min == 59 and sec == 59:
print(str(hour+1)+":00:00")
elif sec == 59:
print(str(hour)+":"+str(min+1)+":"+"00")
else:
print(str(hour)+":"+str(min)+":"+str(sec+1))
11.8 练习8
"""
#8.从控制台输入一句英文，获取在一个单词出现的次数
"""
str1 = input("请输入一段英文：")
name = "today"
dancis = str1.split(" ")
count = 0
for ele in dancis:
if ele == name:
count += 1
print("%s 出现的次数 %d" %(name,count))
二十、函数
1.函数的基本定义
def : 是定义函数的一个关键字
参数
返回值
函数体是使用缩进控制
return 1结束方法 2 返回结果
#没有返回值也没有参数的方法
def fun01():
print("Hello world")
fun01()
fun01()
#有参数 没有返回值
#打印n边的正方形
#有没有参数 有 有几个 有没有返回值 返回什么
def dayin_zfx(n):
for i in range(n):
for j in range(n):
print("*",end="")
print()
print("++++++++++++++++++++++++++++++++++++")
dayin_zfx(5)
print("+++++++++++++++++++++++++=")
dayin_zfx(1)
#有参数也有返回值的
# 写一个方法 求两个数之和
def sumAb(a,b):
#求两个数之和并返回 返回使用return来返回
return a + b
print("+++++++++++++++++++++++++++++++++++=")
jieguo1 = sumAb(10,3)
print(jieguo1)
jieguo2 = sumAb(90,800)
print(jieguo2)
2.使用
2.1 写方法
#1 求1--n之间的和
# 参数 n
# 返回值 sum
def one_to_nsum(n):
sum = 0
for i in range(1,n+1):
sum += i
return sum
print("+++++++++++++")
jieguo1 = one_to_nsum(5)
jieguo3 = one_to_nsum(100)
print(jieguo1,jieguo3)
#求两个数的较大者
# 有两个参数 a b
# 返回较大的
def get_bigger(a,b):
if a > b:
return a
return b
print("+++++++++++++")
print(get_bigger(10,8))
print(get_bigger(7,90))
print(get_bigger(2,2))
#求三个数的较大者
#参数 a b c
#返回最大的
def get_bigger3(a,b,c):
if a > b:
if a > c:
return a
else:
if b > c:
return b
return c#如果最大的不是a 也不是b 那一定是c
print("++++++++++++++++++++++++++++")
print(get_bigger3(10,3,9))
print(get_bigger3(1,90,3))
print(get_bigger3(1,3,90))
#求1--n之间偶数的数量
#参数 n
#返回值 数量
def get_ou_count(n):
count = 0
for i in range(1,n+1):
if i % 2 == 0:
count += 1
return count
print("++++++++++++++++++++++++++++")
print(get_ou_count(10))
2.2 函数的调用
"""
#函数的调用：函数入栈【栈的特点：先进后出，后进先出】
"""
def fun1():
print("=====fun1==begin==")
fun2()
print("=====fun1==end==")
def fun2():
print("=====fun2==begin==")
fun3()
print("=====fun2==end==")
def fun3():
print("=====fun3==begin==")
fun4()
print("=====fun3==end==")
def fun4():
print("=====fun4==begin==")
print("=====fun4==end==")
fun1()
2.3 封装函数，判断某年的平润性
#写一个方法 判断年是不是闰年
def is_run_nian(year):
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
return True
return False
for i in range(2000,2021):
print(i,is_run_nian(i))
##3.封装函数，求1~某个数范围内整数的和
def qiu_he(n):
sum = 0
for i in range(n+1):
sum += i
return sum
print(qiu_he(10))
2.4 练习
"""
方法调用方法
因为方法的功能要单一
功能不混合 有利于调用控制
fun1
fun2
fun3
1 2 3 1 3 2 231 213
"""
#写一个方法 判断一个数是不是质数
#有没有参数 有 一个数 n
def is_zhishu(n):
for i in range(2,n):
if n % i == 0:
return False
#出了循环 还没有return 就说明是质数
return True
#写一个方法 求2--n之间所有的质数的数量
#参数 n
#返回值 质数的数量
def get_zhishu_count(n):
count = 0
for i in range(2,n+1):
#判断i是不是质数
if is_zhishu(i):
count += 1
return count
print(get_zhishu_count(100))
#打印2---n之间的质数
def dayin_zhishu(n):
for i in range(2,n+1):
if is_zhishu(i):
print(i,end=",")
dayin_zhishu(100)
3.参数
3.1
"""
a.必需参数：必须以正确的顺序和正确的类型进行传参，否则会出现错误
"""
def canshu_fun(a,b):
print("姓名 %s 年龄 %d" % (a,b))
canshu_fun("qq",20)
#canshu_fun(20,"qq")#传参的时候要按照形参的顺序传递实参
#canshu_fun("ss")#TypeError: canshu_fun() missing 1 required positional argument: 'b'
#canshu_fun("qq",20,30)#TypeError: canshu_fun() takes 2 positional arguments but 3 were given
3.2
"""
.默认参数：在函数声明的时候给形参设置一个初始值，如果传参的时候不传递实参，则使用默认值，如果传递了参数，则默认值会被覆盖
#c.注意1：默认参数出现在形参列表中，只能出现在整个列表的最后
"""
def canshu_fun(num=0):
print(num)
canshu_fun()#默认值参数如果没有实参 取自己的值
canshu_fun(10)#传了实参 就取实参的值
def canshu_fun2(name,pw,age=10):
print("用户名 %s" % name)
print("密码 %s" % pw)
print("年龄 %s" % age)
print("+++++++++++++++++++++++++++")
canshu_fun2("ww","123")
canshu_fun2("qq","222",30)
3.3
"""
c.关键字参数：传参的时候实参的顺序和形参的顺序可以不一致，因为Python解释器能够使用关键字匹配传参
#注意1：使用关键字参数进行传参，可以不用保持参数的顺序一致，，关键字的名称使用的形参的变量名
#注意2：在实参列表中，如果有部分参数设置成了关键字参数，则关键字参数必须出现在实参列表的最后
"""
def guan_jianzi_fun1(name,pw,age):
print("姓名 %s" % (name))
print("密码 %s" % (pw))
print("年龄 %d" % (age))
print("++++++++++++++关键字参数体现在方法被调用的时候 也就是实参中+++++++++++++++++++")
guan_jianzi_fun1("qq","999",20)
print("++++++++++++++++++")
guan_jianzi_fun1(age=30,name="张飞",pw="888")
print("+++++++++")
guan_jianzi_fun1("关羽","123",age=28)
print("+++++++++++++++")
#guan_jianzi_fun1(30,name="曹操",pw="000")#TypeError: guan_jianzi_fun1() got multiple values for argument 'name'
#不用关键字参数 就得按顺序 后面的可以用
3.4
"""
d.不定长参数【可变参数】：函数在实现的时候可以处理比声明时候更多的数据
"""
def sum1(a,b):
return a + b
def sum2(a,b,c):
return a + b + c
"""
#不定长参数【可变参数】
#1.*
#a。
#注意1：*xxxx,则被当做元组处理，xxx就是一个元组的名称
"""
#求n个数之和
def sum_n(*nums):
#print(num)
sum = 0
for ele in nums:
sum += ele
return sum
sum11 = sum_n(1,2,3)#(1, 2, 3)
print(sum11)
sum22 = sum_n(1,2,3,4,5)#(1, 2, 3,4,5)
print(sum22)
print("++++++++++++++++++++++#注意3：在形参列表中，不定长参数使用在列表的最后+++++++++++++++++++++++++++++++++")
#求两个固定数与不定多个数之和
def kebian(a,b,*nums):
sum = 0
sum += a
sum += b
for ele in nums:
sum += ele
return sum
print(kebian(1,99,1,2,3,4,5))
def kebian2(*nums,a,b):
return a + b
#kebian2(1,2,3,4)#TypeError: kebian2() missing 2 required keyword-only arguments: 'a' and 'b'
jieguo = kebian2(1,2,3,a=10,b=9)
print(jieguo)
3.5
"""
#【面试题】
#注意：不管是列表还是元组，最终*xxx得到的结果都是一个列表，不同的变量进行数值的分配
"""
a,b=3,4
print(a,b)
a,b,*c= (1,2,3,4,5)
print(a,b,c)
a,*b,c = (1,2,3,4,5)
print(a,b,c)
*a,b,c = (1,2,3,4,5)
print(a,b,c)
def fun1(*a,b,c):
print(a,b,c)
fun1(1,2,3,b=9,c=10)
3.6
"""
#注意1：**xxx,xxx会被当做字典进行处理，传参的时候实参必需以key=value的方式进行传参
"""
def fun1(**num):
#形参被认为是一个字典
print(num)
for key,value in num.items():
print(key,value)
fun1(a=10,b=9)#关键字就会作为字典的键 值就会作字典的值
#姓名 qq 年龄 20 pw 999
fun1(name="qq",pw="999",age=20)
fun1(age=80,sex="man",email="ww@qq.com")
3.7 练习
#1.封装函数，对一个列表使用冒泡进行排序【模拟sort的使用:默认升序排序，指明条件的时候降序排序】
def mysort(newlist,reverse=False): #默认值参数
#冒泡排序
if reverse:#如果是真 就降序 否则升序
for i in range(len(newlist)-1):
for j in range(len(newlist)-1-i):
if newlist[j] < newlist[j+1]:
newlist[j], newlist[j + 1] = newlist[j + 1], newlist[j]
else:#升序
for i in range(len(newlist)-1):
for j in range(len(newlist)-1-i):
if newlist[j] > newlist[j+1]:
newlist[j],newlist[j+1] = newlist[j+1],newlist[j]
list1 = [1,23,8,90,100,93,4]
print(list1)
mysort(list1)
print(list1)
mysort(list1,reverse=True)
print(list1)
4.值传递和引用传递
"""
##### 值传递和引用传递【面试题】
> 值传递：传递的是不可变的数据类型，如：number,str,tuple,bool
>
> 引用传递：传递的是可变的数据类型，如：list,dict,set
结论：
值传递：传递的是不可变的数据类型，如果形参发生改变，对实参没有影响
引用传递：传递的是可变的数据类型，如果形参发生改变，实参也会随着改变
值传递 --- 就是将值传进去
引用传递 --- 传递的是地址 改变原始值
"""
#值传递的例子
def fun1(num):
num += 1
print(num)
num1 = 9
fun1(num1)
print(num1)
def fun2(name):
name = "hello"
print(name)
name1 = "uu"
fun2(name1)
print(name1)
print("++++++++++++++++++++++++++++++")
#引用传递的例子
def fun3(list1:list):
list1.reverse()
print(list1)
list2 = [2,34,1]
print(list2)
fun3(list2)
print(list2)
#字典
def fun4(dict1:dict):
dict1["aa"] = 99
dict2 = {"aa":100,"cc":80,"vv":8}
print(dict2)
fun4(dict2)
print(dict2)
5.返回值
5.1
"""
返回值
"""
def fun1():
pass
jieguo = fun1()
print(jieguo)
def fun2():
return 10
jieguo2 = fun2()
print(jieguo2)
print("+++++++++++++++++++++++++++++")
def fun3(num):
if num == -1:
return
print(num)
return num + 1
jieguo4 = fun3(9)
print(jieguo4)
jieguo3 = fun3(-1)
print(jieguo3)
"""
#4.return存在的意义：在函数内部运算的结果，如果想要在函数外部进行访问，直接访问不到【变量是有作用域的】，
# 则可以通过返回值的形式返回给调用者
"""
print("+++++++++++++++++++++++++++++++")
def fun4(num):
num = num + 90
print(num,end="+++++++")
return num
num1 = 9
num2 = fun4(num1)#值传递的时候 num的作用域在方法内 只能通过返回值的方式记录其变化
print(num1)
print(num2)
5.2
""""
#5.特殊情况一：return后面可以跟多个数据,.在函数外面调用获取的结果为一个元组
"""
def fun1(num,num2,num3):
num += 1
num2 += 2
num3 += 3
return num,num2,num3
a = 10
b = 10
c = 10
print(a,b,c)
jieguo1 = fun1(a,b,c)
print(jieguo1)#(11, 12, 13)
a = jieguo1[0]
b = jieguo1[1]
c = jieguo1[2]
print(a,b,c)
5.3
"""
#6.特殊情况二：函数中的多分支中也可以使用return，不同的分支可以有不同类型的返回值，
# 不同的分支可以根据具体的情况决定是否需要设置返回值【原理：Python是一种弱类型的语言】
"""
def fun1(sex):
if sex == "man":
return "good boy"
else:
return "good girl"
jieguo1 = fun1("man")
print(jieguo1)
jieguo2 = fun1("uu")
print(jieguo2)
5.4
"""
#7.特殊情况三：break和return之间的区别
#break仅仅使用在循环中，结束当前的循环,
#return使用在函数中，结束当前函数，不管return存在于多少层嵌套循环中，一旦遇到return，整个函数都会结束
#在某些情境下，可以使用return代替break
"""
#判断循环是否包含第二个数字
def fun01(n,m):
for i in range(n):
if i == m:
return 100
return -1
jieguo1 = fun01(10,8)
print(jieguo1)
jieguo2 = fun01(10,90)
print(jieguo2)
6.递归
6.1
"""
7: 使用递归来实现斐波那契数列的前N项的和
1,1,2,3,5,8,13,21,34.....
定义两个方法
一个数列值
一个求和
f(n) = f(n-1)+f(n-2)
f(2) = 1
f(1) = 1
"""
#写一个方法求第n项的值
def get_fbnq(n):
#先写出口
if n == 1 or n == 2:
return 1
return get_fbnq(n-1) + get_fbnq(n-2)
for i in range(1,15):
print(get_fbnq(i),end=",")
#再写一个方法求前n项的和
def get_sum_fbnq(n):
sum = 0
for i in range(1,n+1):
sum += get_fbnq(i)
return sum
print()
print("前10项的和%s" % get_sum_fbnq(10))
6.2
"""
7: 使用递归来实现斐波那契数列的前N项的和
1,1,2,3,5,8,13,21,34.....
定义两个方法
一个数列值
一个求和
f(n) = f(n-1)+f(n-2)
f(2) = 1
f(1) = 1
"""
#写一个方法求第n项的值
def get_fbnq(n):
#先写出口
if n == 1 or n == 2:
return 1
return get_fbnq(n-1) + get_fbnq(n-2)
for i in range(1,15):
print(get_fbnq(i),end=",")
#再写一个方法求前n项的和
def get_sum_fbnq(n):
sum = 0
for i in range(1,n+1):
sum += get_fbnq(i)
return sum
print()
print("前10项的和%s" % get_sum_fbnq(10))
二十一、list 列表生成式和生成器
1 列表生成式
1.1 list(range())
#1.方法1
range1 = range(1,10,2)
list1 = list(range1)
print(list1)
print("++++++++++++++++++++")
#2.方法2
list1 = []
for i in range(2,11,2):
list1.append(i)
print(list1)
1.2 list中for循环的简写方式
#1.类型1
list1 = [i ** 3 for i in range(1,10)]
print(list1)
list2 = [i ** 3 +1 for i in range(1,6)]
print(list2)
#2.类型2
list3 = [i ** 3 for i in range(1,10) if i % 2 == 0]
print(list3)
#3.类型3(笛卡尔积)
name_list = ["张飞","关羽","刘备"]
age_list = [30,32,39]
list_person = [name + "的年龄：" + str(age) for name in name_list for age in age_list]
print(list_person)
1.3 在列表生成式中，for循环中也可以使用多个变量
dict1 = {"k1":"v1","k2":"v2"}
list1 = [key + "--" + value for key,value in dict1.items()]
print(list1)
1.4 练习
list1 = ["Aaa","vsf","HELLo"]
list2 = [ele.lower() for ele in list1]
print(list2)
1.5 isinstance(变量，类型)，判断一个变量是否是指定的数据类型，是则返回true
a = 10
if isinstance(a,int):
print(True)
else:
print(False)
x = "hello"
if isinstance(x,str):
print(True)
else:
print(False)
print("++++++++++++++++++++++")
list1 = ["qq","uu","ww",10]
for ele in list1:
if isinstance(ele,str):
print(ele + "kk")
2 生成器（不重要，过）
可迭代对象和迭代器
1 可迭代对象
只能用for循环遍历的数据被称为可迭代对象【Iterable类】
可迭代对象的数据类型：
a.集合数据类型：
list,tuple,dict,set,str b.generator:包括()生成器和带yield关键字的函数
from collections.abc import Iterable
list1 = [1,2,3]
tuple1 = (1,2)
dict1 = {"k1":"v1","k1":"v2"}
set1 = {1,2}
print(isinstance(list1,Iterable))
print(isinstance(tuple1,Iterable))
print(isinstance(dict1,Iterable))
print(isinstance(set1,Iterable))
print("ss",Iterable)
2 迭代器（过）
函数的本质
1.变量可以指向函数
函数本身就代表它自己
函数名就是函数对象
可以使用别的变量来接收这个对象
print(abs(-10))
print(abs)#<built-in function abs>
def fun1():
pass
print(fun1)#<function fun1 at 0x000002C68C7FC1E0>
x = -10
a = abs
print(a(x))
2.函数名是一个变量名
不能使用系统函数当做变量名
abs = 9 #将系统的abs覆盖掉了
print(abs(-9))#报错 TypeError: 'int' object is not callable
max = 10
list1 = [10,2,3]
max1 = max(list1)#报错 TypeError: 'int' object is not callable
3.函数可以作为参数
#1.练习1
def fun1(n):
return n**2 + 1
def fun2(x,y):
fun1(x) + fun2(y)
def fun3(x,y,f1):
return f1(x) + f1(y)
jieguo1 = fun3(3,4,fun1)
#2.练习2
def fun21(n):
return n**2
def fun22(n):
return n**3
def fun23(x,y,f1,f2):
return f1(x)+f1(y)+f2(x)+f2(y)
jieguo1 = fun23(1,2,fun21,fun22)
print(jieguo1)
二十二、闭包【了解】
如果在一个函数的内部定义了另外一个函数，外部的函数被称为外部函数【outter】,里面的函数被称为内部很熟【inner】
在一个外部函数中定义一个内部函数，并且外部函数的返回值为内部函数的引用，这样就构成了闭包【Closure】
1 简单的闭包【没有参数】
def outter1():
#在方法里面定义了另外一个方法 将这个方法的引用作为外部的方法的返回值
def inner1():
print("====闭包函数被调用了====")
return 10
return inner1 #方法名就是方法本身 -- 方法名就是方法这个对象的一个引用
fun1 = outter1()#通过调用外部方法得到闭包方法的对象
fun1()
2 闭包有参数，外部函数没有参数
def outter2():
def inner2(a):
print("====闭包被调用了====")
return a ** 3
return inner2
fun2 = outter2()
jieguo = fun2(3)
print(jieguo)
3 闭包有参数，外部函数也有参数，尽量不要使用同名参数
def outter3(x):
def inner3(y):
return x ** 2 + y ** 2
return inner3
fun3 = outter3(3)
jieguo3 = fun3(2)
print(jieguo3)
二十三、变量的作用域【了解】
1.概念
出现的原因：变量的作用域指的是变量可以被访问的范围
程序中的变量并不是在任意的位置都可以访问，访问权限取决于该变量被定义的位置
变量的生命周期也决定了变量被访问的范围
分类：
L:local,局部作用域
E:Enclosing,函数作用域【定义在方法内，只能在方法内使用】
G:Global,全局作用域(在.py文件任意一个位置都能使用)
B:Built-in,內建作用域【内置作用域】 a = abs
#1.
a = 10
print(a)
def fun1():
print(a)
fun1()
print("++++++++++++++++++++")
#2.
def fun2():
num1 = 8 #函数作用域 这个num1的使用范围是这个函数
print(num1)
print(num1)#函数外部不能访问
for i in [1,2,3]:
print(i)
print(i)
def fun3():
for j in [1,2,3]:
print(j)
print(j)#外部不能访问
2.查找规则
kk = 10
def fun4():
kk = 7
print(kk)
fun(4)
if True:
xx == 7
print(xx)
3.全局变量和局部变量
说明：全局和局部只是一个相对的概念
4 global和nonlocal关键字
4.1 global
a = 20
def test():
global a #在这个函数中操作的变量是外部的那个全局变量a
a += 1
test()
print(a)
4.2 nonlocal
nonlocal只能使用在闭包中
二十四、装饰器基本用法
如果增强一个函数的功能但是又不希望原函数被修改，这种代码运行的期间动态增加函数功能的机制被称为装饰器【Decorator】
装饰器的本质：就是一个闭包，只是需要被装饰的函数当做参数传递给闭包，最后返回装饰之后的结果【内部函数的引用】
高阶函数：将一个函数作为另外一个函数的参数，返回一个结果
def fun1():
print("===功能001===")
print("---功能002---")
def outter(f):#f -- 将来可以接收fun1的引用 当然在闭包中对传递进来的函数功能进行扩展
def inner():
print("----扩展功能001----")
f()
print("----扩展功能002----")
return inner
in1 = outter(fun1)
in1()
print("++++++++装饰完后 原函数功能不变++++++++++")
fun1()
1 实现一个装饰器，可以计算函数的执行时间
def fun1():
for i in range(100000):
print(i,end=",")
def fun2():
for i in range(50000):
print(i,end=",")
def outter(f):
def inner():
start = time.time()
f()
end = time.time()
print("函数执行时间：%s" % (end-start))
return inner
in1 = outter(fun1)
in1()
print("++++++++++++++++++")
in2 = outter(fun2)
in2()
二十五、栈和队列
1 栈
特点：先进后出，后进先出
1.1 列表的底层维护了一个栈结构
stack = []
print("+++++++++入栈++++++++++")
def fun1(name):
stack.append(name)
def fun2():
stack.pop()
fun1("张飞")
print(stack)
fun1("关羽")
print(stack)
fun1("刘备")
print(stack)
fun2()
print(stack)
fun2()
print(stack)
fun2()
print(stack)
2 队列
先进先出，后进后出
import collections
queue = collections.deque()
def fun3(name):
queue.append(name)
def fun4():
queue.popleft()
fun3("张飞")
print(queue)
fun3("刘备")
print(queue)
fun3("曹操")
print(queue)
fun4()
print(queue)
fun4()
print(queue)
fun4()
print(queue)
二十六、目录遍历
1.os模块
os:operation system
1.1 os.listdir(path),获取一个指定路径下所有的内容【包含文件和文件夹】
返回值：返回一个列表，列表中的元素是文件或者文件夹的名称
path = r"C:\Users\Administrator\Desktop\XA-Python1905"
import os
path1 = r"E:\pythonjiaoben"
print(path1)
print(type(path1))
files = os.listdir(path1)
print(files)
1.2 拼接路径
方式一：subPath = path + “\” + “Day2Code”
方式二：os.path.join(父路径，文件或者文件夹的名称)：拼接路径
- 返回值：新的路径
import os
path1 = r"E:\pythonjiaoben"
path2 = path1 + "\\" +"day49"
print(path2)
path3 = os.path.join(path1,"day49")
print(path3)
1.3 判断一个路径是否是文件或者文件夹
isfile(path):判断指定的路径是否是文件，如果为True，则表示是文件
isdir(path)：判断指定的路径是否是目录，如果为True，则表示是目录
import os
path2 = r"E:\pythonjiaoben\day49"
path3 = os.path.join(path2,"bibao.py")
print(os.path.isfile(path3))
print(os.path.isdir(path3))
2.递归遍历目录
需求：封装函数，获取一个指定目录下所有的内容，如果是文件，则直接打印，如果是文件夹，则继续查找
2.1 例1：遍历文件夹
import os
def getAllFile(path):
#判断这个文件夹是否存在，如果不存在直接停止
if not os.path.exists(path):
print("路径不存在，无法操作")
return
#判断这个path是不是一个真的文件夹，如果是文件，不需要遍历
if os.path.isfile(path):
print("路径是一个文件：%s" % path)
return
#说明这个path是一个文件夹 并且存在
#获取这个目录下的所有文件及文件夹
file_list = os.listdir(path)
for file in file_list:
file_name = os.path.join(path,file)
if os.path.isdir(file_name):
getAllFile(file_name)#递归遍历
else:
print("路径是一个文件：%s" % file_name)
if __name__ == "__main__":
path1 = r"E:\pythonjiaoben"
getAllFile(path1)
2.2 例2 .png 文件
import os
def get_all_png(path):
if not os.path.exists(path):
print("该目录不存在")
return
if os.path.isfile(path):
print("这是一个文件：%s" % path)
return
file_list = os.listdir(path)
for file in file_list:
if os.path.isdir(path):
file_name = os.path.join(path,file)
get_all_png(file_name)
else:
if file_name.endwith(".png"):
print("这是一个文件：%s" % file_name)
if __name__ == "__main__":
path1 = r"E:\day49"
get_all_png(path1)
二十七、包
包：初期理解为文件夹【目录】
包是一种管理Python模块命名空间的形式，采用“点语法”，避免文件或者文件夹的命名冲突的情况
注意：包和普通文件夹之间的区别：包下必须存在一个文件，名称为:init.py,目前该文件为空，表示当前的文件夹并不是一个普通的文件夹，而是一个包，后期会在该文件中书写一个项目的配置信息
#测试的模块
#首先导入模块
import bao1.moudle1
import bao2.moudle2
print(bao1.moudle1.a1)
bao1.moudle1.fun1()
print("+++++++++++++++++++++++++++++++++++++")
print(bao2.moudle2.a2)
bao2.moudle2.fun2()
二十八、自定义模块
1 import xxxx
优点：不同的模块中出现重名的变量或者函数，相互之间没有任何影响
缺点：import xxx不管什么样的情况下，访问模块中的内容，都需要指明变量或者函数的来源
import aaa.moudle01
print(aaa.moudle01.str1)
aaa.moudle01.func()
2 form xxx import xxx
格式：from 模块名 import 变量名，函数名或者类名
优点：
- 访问变量和调用函数代码比较简化，不需要对变量或者函数的来源进行声明
- 根据具体的需求可以选择性的导入变量或者函数，可以节约内存空间
缺点：
- 如果不同的模块中出现了重名的变量或者函数，则后导入的变量或者函数会覆盖之前的
- 如果一个模块中有大量的变量或者函数需要导入，则需要挨个书写，可以使用from … import *简化
- 如果在当前文件中出现和模块中重名的函数或者变量，则调用的是当前文件
自定义的模块一般建议使用from …import …的方式导入
from bao1.moudle1 import a1,fun1
from bao2.moudle2 import a2,fun2
print(a1)
print(a2)
print(fun1)
print(fun2)
二十九、系统模块
1 时间模块
掌握：时间不同形式之间的转换
时间间隔：是以秒为单位的浮点数
时间戳：从1970.1.1 00:00:00开始到指定时间的秒数
1.1 time
UTC:格林威治天文时间，世界标准时间，在中国UTC+8
时间的表示形式：
a.时间戳形式
以整型或者浮点型表示的一个以秒为单位的时间间隔，从1970.1.1 00:00:00开始到指定时间的秒数
b.元组形式
时间的元组形式
【year:年，month:月，day:天，hour；时，minutes:分，seconds；秒，weekday:星期，day in year:一年中的第几天，isdst:是否是夏令时，0表示正常格式，1表示夏令时格式，-1表示自定义格式】
注意：
month的取值范围:1~12
weekday的取值范围：0~6,0表示星期一
c.字符串形式
使用格式化的方式表示时间
%Y:年份
%m:月份
%d:日
%H；24小时制
%M:分
%S:秒
time.time()
time.gmtime()
time.localtime()：获取当地时间的元组形式
time.mktime
time.ctime
import time
print(time.time())
print("++++++获取UTC的元组形式++++++")
time2 = time.gmtime()
print(time2)
print(time2[0])
print(time2[1])
print(time2[2])
print("++++++++++获取当地时间的元组+++++++++++")
time3 = time.localtime()
print(time3)
#将元组形式转换为时间戳形式
time4 = time.mktime(time3)
print(time4)
#将时间的时间戳形式转换为字符串形式
print(time.ctime(time.time()))
#将时间的元组形式转换为字符串形式：默认格式
print(time.asctime(time3))
#将时间的元组形式转化为字符串形式：自定义格式strftime
time5 = time.strftime("%Y--%m--%d",time3)
print(time5)
#time.sleep
print("====开始睡=====")
time.sleep(10)
print("=====醒了=======")
1.2 datetime模块
import datetime
#1.获取当前时间
d1 = datetime.datetime.now()
print(d1)
##2.获取指定时间[年月日时分秒毫秒]
d2 = datetime.datetime(1996,10,20,10,10,10,100)
print(d2)
##3.字符串和datetime类型之间的转换
d3 = d1.strftime("%Y===%m=====%d")
print(d3)
#4.datetime时间对象之间可以进行加法运算
date1 = datetime.datetime(1996,10,20,10,10,10,100)
date2 = datetime.datetime(2020,11,20,10,10,50,100)
cha = date2 - date1
print(cha)
print(cha.days)
print(cha.seconds)
1.3 calendar 日历
isleap 判断是不是闰年
"""
calendar模块
"""
import calendar
print(calendar.isleap(2000))#判断是否是瑞年
print(type(calendar.month(1998,10)))
print(calendar.month(1998,10))
print(calendar.calendar(2000))
2.os模块
2.1 获取环境变量
import os
print(os.name)
##2.获取当前操作系统中的环境变量
print(os.environ)
print("++++++++++++++++++++++++++++++++++++++++++++++")
print(os.environ.get("JAVA_HOME"))
print("+++++++++++++++++++++")
print(os.environ.get("MYSQL_HOME"))
print(os.environ.get("PATH"))
paths = os.environ.get("PATH")
print(type(paths))
lists = paths.split(";")
for nr in lists:
print(nr)
print("++++++++++++++++++++++++++++++++++++++++++++")
print(os.curdir)
"""
#二、函数
#二、一：os下的函数
#1.获取当前工作目录
"""
print(os.getcwd())#D:\PycharmProjects\2202\day49code\xitongmokuai2
2.2 文件相关
"""
创建文件 mkdir
"""
import os
path1 = r"D:\2202\day49\uu"
if not os.path.exists(path1):
os.mkdir(path1)
print("===文件夹创建成功====")
path2 = r"kk"
if not os.path.exists(path2):
os.mkdir(path2)
print("====文件夹2创建成功")
zi1 = os.path.join(path1,"killer")
if not os.path.exists(zi1):
os.mkdir(zi1)
print("====文件夹3创建成功")
print("+++++++++++++++++++")
if os.path.exists(zi1):
os.rmdir(zi1)
print("===删除成功====")
print("++++++++++++++++++++++++++++++++++++++")
file = r"D:\2202\day49\uu\qq.txt"
#print(os.stat(file))
#os.stat_result(st_mode=33206, st_ino=3940649674274606, st_dev=170019028, st_nlink=1,
#st_uid=0, st_gid=0, st_size=8, st_atime=1652775705, st_mtime=1652775705, st_ctime=1652775684)
os.rename(file,r"D:\2202\day49\uu\qq2.txt")
#file1 = r"D:\2202\day49\uu\qq2.txt"
#os.remove(file1)
#os system 可以执行系统命令
#os.system("notepad")
#os.system("winmine")
print(os.path.abspath("kk"))#D:\PycharmProjects\2202\day49code\xitongmokuai2\kk
##3.拆分路径
#注意：得到的结果为一个元组（父路径，子路径）
r2 = os.path.split(file)
print(r2)
##6.获取文件大小，返回字节数 *****
print(os.path.getsize(file))
##7.获取文件的目录
print(os.path.basename(file))#文件子路径
print(os.path.dirname(file))#父路径
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0uIAwBoU-1679826628525)(C:\Users\11700\AppData\Roaming\Typora\typora-user-images\image-20220517165824945.png)]
3 logging 日志
作用：记录程序的运行过程，记录变量 时间执行信息 用以分析程序的错误
"""
python中打日志
记录程序的运行过程 记录变量 时间执行信息 用以分析程序的错误
事件的严重程度：
debug
info
notice
warning
errors
critical
alter
emergency
"""
import logging
print("++++++++++++两组方法====")
#设置日期的格式
dateFormat = "%m/%d/%Y %H:%M:%S"
logformat = "%(asctime)s - %(levelname)s - %(message)s"
logging.basicConfig(filename="my.log",level=logging.ERROR,format=logformat,datefmt=dateFormat)
a = 10
b = 3
logging.debug("===========debug=====")
logging.info("===========info=====")
logging.warning("+++++++++++warning+++++++++++++")
logging.error("===========error=====")
logging.critical("===========critical=====")
print("+++++++++++++++++++++++++++++++++++++++++++++++++++")
logging.log(logging.ERROR,"++++++++++++++++++ERROR++++++++++++")
4 sys模块
import sys
print(sys.path)
print("++++++++++++++++++")
print(sys.platform)
5 hashlib 加密模块
"""
hashlib模块
"""
import hashlib
md51 = hashlib.md5()
md51.update("hello 123".encode("utf-8"))
print(md51.hexdigest())#1bb45824de71b2f6476d800f427cb2ab
#1bb45824de71b2f6476d800f427cb2ab
#"hello 123" ---> 1bb45824de71b2f6476d800f427cb2ab
md51.update("hello 123 ".encode("utf-8"))
print(md51.hexdigest())
python 面向对象
一、面向过程 和 面向对象的区别
1. 面向过程
1.冰箱装大象 以我为视角
打开冰箱 --> 把大象装进去 --> 关上冰箱门
2.人抢银行
2. 面向对象
面对象是一种思想，比较抽象
1.冰箱装大象
冰箱 --> 具有装大象功能
大象 --> 被装进去
冰箱自己打开冰箱门 --> 大象自己走进去了 --> 冰箱门关上了
2.人抢银行
人 --> 有抢银行的功能
银行 --> 有防抢的功能
3. 区别(面试题)：
把人从执行者变成了一个控制者
面向过程：
优点：性能比面向对象高，
缺点：开销比较大，比较耗资源，没有面向对象易于维护，易于扩展，易于复用
面向对象：
优点：易于维护，易于扩展，易于复用，由于面向对象有封装，继承和多态的特定，可以设计出低耦合的应用，使得系统更加灵活
缺点：性能比面向过程低
二、类和对象【重点掌握】
1.概念
类：多个具有特殊功能的个体的集合
对象：在一个类中，一个具有特殊功能的个体，能够帮忙完成某件事情，也被称为实例
2.定义类
语法：
def 函数名():
函数体
class 类名():
类体
说明：
a.Python中使用class关键字定义类
b.类名:只要是一个合法的标识符即可，但是，类名尽量是大驼峰，尽量做到见名知意
c.():目前，（）为空，不要省略
d.类体：Python中通过缩进来区分类体
e.类的定义包含两部分：类的声明和类的实现
f.类体包含两部分：对类的特征的描述（属性）和对类的行为的描述（功能）
3.设计类
类体中需要书写哪些内容
要设计一个类，只需要关心3个要素
事物名称：类名，如：人【Person】
事物的特征:变量，如：姓名【name】,年龄【age】
事物的行为：函数，如：跑步，唱歌
注意：初期学习，通过提取动名词描述类
三、类中的方法【函数】和属性【重点掌握】
定义在类中的内容被称为类中的成员
成员变量：类具有的特征【多个对象具有的共同的特征】，也称为属性
成员方法：类具有的行为【多个对象具有的共同的行为】
1.类体的实现
self：当前类对象
#需求：描述人类，特征：姓名，年龄 行为：跑步，吃饭
class Person():
name = "qq"
age = 20
def run(self):
print("%s 在跑步" % self.name)
def eat(self):
print("%s 在吃饭" % self,name)
2.对象的创建
对象的创建过程其实就是定义一个类的变量【创建对象也被称为实例化对象】
num = 10
语法：变量名 = 对象
对象名 = 类名()
from day50.duixiang.shili01 import Person
#使用类创建对象 方法就是类名（）
if __name__ == "__main__":
a = 10
print(a)
print(type(a))#<class 'int'>
print("++++++++++++++++++++++++++")
person1 = Person()
print(person1)#<shiti.shili001.Person object at 0x000002C7D40B3B70>
print(type(person1))#<class 'shiti.shili001.Person'>
print("+++++++++++")
person2 = Person()
print(person2)
print(person1 is person2)
print(id(person1))
print(id(person2))
3.访问类中的成员
使用对象来访问成员
使用对象.的方式来访问
person1 = Person()
person1.name
person1.run()
from day50.duixiang.shili01 import Person
if __name__ == "__main__":
person01 = Person()
person01.name = "张飞"
person01.age = 30
person01.run()
person01.eat()
4.综合练习
4.1 练习1
需求：开学了，张老师让学生【小明，小花，小丽】做自我介绍
要求：姓名，年龄，爱好，来一段才艺展示
"""
分析
老师类
特征：姓名
行为;让。。。。。
学生类
特征：姓名，年龄，爱好
行为：作自我介绍，来一段才艺展示
"""
class Student():
#成员变量
name = ""
age = 10
hobby = ""
def introduce(self):
print("我叫 %s 年龄 %d 爱好 %s" %(self.name,self.age,self.hobby))
class Teacher():
#成员变量
name = ""
def let_stu_caiyi(self,stu:Student):
print("======%s=====" % self.name)
stu.introduce()
if __name__ =="__main__":
xm = Student()#xm--变量 称之为对象的引用 右边是对象的实体 对象的引用指向了对象的实体
xm.name = "小明"
xm.age = 11
xm.hobby = "乒乓球"
xh = Student()
ls = Teacher()
ls.let_stu_caiyi(xm)
四、动态绑定属性和限制绑定
对象的属性除了定义之外 还可以动态加入属性
slots：限定可以绑定的属性
class Person():
__slots__ = ("sex","email")#限定可以绑定的属性
name = "qq"
age = 10
def show(self):
print(self.name,self.age)
p1 = Person()
print(p1)
print(p1.name)
print(p1.age)
p1.sex = "man"
print(p1.sex)
五、构造函数和析构函数
1.构造函数
作用：主要用于创建对象并将对象的数据做出初始化
构造函数，也被称为构造器，指的是当创建对象的时候，被自动调用的函数
语法：
def __init__(self): pass
def __str__(self):返回字符串形式
1.1 例1
class Person():
#空参函数
def __init__(self):
print("++++++++构造函数被调用+++++++")
p1 = Person()#构造函数在创建对象的时候就会被调用
print("++++++++++++++++++++++")
#带参函数
class Person2():
def __init__(self,name):
self.name = name
def __str__(self):
return "姓名："+self.name
p2 = Person2("张飞")
print(p2)
print("++++++++++++++++++++++")
class Person3():
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return "姓名："+self.name + " 年龄：" + str(self.age)
p3 = Person3("刘备",30)
print(p3)
2.案例
2.1 案例1
需求：开学了，张老师让学生【小明，小花，小丽】做自我介绍
要求：姓名，年龄，爱好，来一段才艺展示
分析
老师类
特征：姓名
行为：让。。。。。学生类
特征：姓名，年龄，爱好
行为：作自我介绍，来一段才艺展示
class Student():
def __init__(self,name,age,hobby):
self.name = name
self.age = age
self.hobby = hobby
def show(self):
print("我叫 %s ,年龄是：%s ,爱好是：%s" % (self.name,self.age,self.hobby))
class Teacher():
def __init__(self,name):
self.name = name
def let(self,stu:Student):
print(self.name)
stu.show()
print("++++++++++++++++++++++")
p1 = Student("小明",20,"打篮球")
p2 = Student("小花",21,"唱歌")
p3 = Student("小丽",23,"跳舞")
t1 = Teacher("李老师")
t1.let(p1)
t1.let(p2)
t1.let(p3)
2.2 案例2
构造一个圆，求该圆的面积和周长，判断一个点和圆之间的关系
对象：圆心，圆，一个点
类：
圆类
特征：圆心和半径
行为：面积和周长
点类
特征：x坐标和y坐标
import math
class Point():
def __init__(self,x,y):
self.x = x
self.y = y
def __str__(self):
return "横坐标是：%s 纵坐标是：%s" % (self.x,self.y)
class Circle():
def __init__(self,o,r):
self.r = r
self.o = o
def __str__(self):
return "圆心是：%s 半径是：%s" % (self.o,r)
def per(self):
return 2 * math.pi * self.r
def area(self):
return math.pi * r ** 2
def rs(self,point:Point):
length = math.sqrt((point.x - self.o.x) ** 2 + (point.y - self.o.y) ** 2)
if length > r:
return "点在圆外"
elif length == r:
return "点在圆上"
else:
return "点在圆内"
p1 = Point(1,2)
print(p1)
r = 3
circle1 = Circle(p1,r)
print(circle1)
print(circle1.per())
print(circle1.area())
p2 = Point(3,5)
print(circle1.rs(p2))
2.3 案例3
时钟类
特征：时分秒
行为：走针
class Clock():
def __init__(self,hour,min,sec):
self.hour = hour
self.min = min
self.sec = sec
def __str__(self):
return str(self.hour)+":"+str(self.min)+":"+str(self.sec)
def running(self):
if self.hour == 11 and self.min == 59 and self.sec == 59:
self.hour = 0
self.min = 0
self.sec = 0
elif self.min == 59 and self.sec == 59:
self.hour += 1
self.min = 0
self.sec = 0
elif self.sec == 59:
self.min += 1
self.sec = 0
else:
self.sec += 1
print("++++++++++++++++++++++++++++")
clock = Clock(11,59,59)
clock.running()
print(clock)
3.def __str__(self):
这个方法的作用是 复写(上帝类) 父类的将对象转换成字符串的方法，就是说如果这个方法被重写，打印对象的时候就会以这个方法的规则来打印对象，这个方法的返回值就是这个对象的字符串的存在形式
class Person():
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def __str__(self):
return self.name + "--" + str(self.age) + "--" + self.sex
p1 = Person("张飞",30,"man")
print(p1)
4.析构函数
和构造函数相反，当对象被销毁的时候自动调用的函数，被称为析构函数，函数名为
__del__对象被销毁的时机：
a.程序执行完毕，对象的生命周期自然完成
b.程序还未执行完毕，但是手动销毁对象：del 变量名
一个对象被回收的前提是没有任何一个引用指向这个对象
import time
class Person():
def __init__(self,name):
self.name = name
print("===构造了一个对象==" + self.name)
def __del__(self):
print("==析构函数被调用了== %s 被回收了" % self.name )
print("+++++++++++++++++")
print("+++++++++++begin++++++++++++++")
p1 = Person("武松")
p2 = Person("张飞")
p3 = Person("宋江")
p4 = p1
del p1#删除p1,自动调用del
time.sleep(5)
del p3
time.sleep(5)
四、封装
1.概念
封装的好处：提高了数据的安全性，提高了数据的复用性
私有可以用到类体中
2.属性未被私有化
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return self.name +" " + str(self.age)
print("++++++++++++++++++++++++++")
p1 = Person("武松", 30)
print(p1)
print(p1.name)
3.属性私有化，提供get和set方法
class Person:
def __init__(self,name,age):
self.__name = name
self.__age = age
def __str__(self):
return self.__name + " " + str(self.__age)
def getName(self):
return self.__name
def setName(self,new_name):
self.__name = new_name
def getAge(self):
return self.__age
def setAge(self,new_age):
self.__age = new_age
print("++++++++++++++++++")
p1 = Person("武松",28)
print(p1)
print(p1.getName())
p1.setName("武力")
print(p1)
4.@property装饰器
装饰器：可以给函数动态的增加功能，对于类的成员函数，装饰器同样可以使用
Python内置的装饰器@property的作用：将一个函数当做属性访问
注意：@property可以单独使用，也可以和@属性名.setter组合使用【@属性名.setter只能有@property生成】
作用：使用在类的成员函数中，可以 简化代码，可以提高代码的复用性，同时也可以保证对参数进行校验
@property 这是一个获取属性的方法
@属性.setter 这是一个属性的set方法
# 使用装饰器@property 和 @xxx.setter 来完成get和set方法
class Person:
def __init__(self, name, age):
self.__name = name
self.__age = age
def __str__(self):
return self.__name + " " + str(self.__age)
@property
def name(self):
return self.__name
@name.setter
def name(self,name):
self.__name = name
@property
def age(self):
return self.__age
@age.setter
def age(self,age):
self.__age = age
if __name__ == "__main__":
p1 = Person("张飞",22)
print(p1)
print(p1.name)
print(p1.age)
p1.name = "刘备"
p1.age = 24
print(p1)
5 练习
"""
1.使用封装的思想结合列表完成下面题目
学生类：姓名、年龄、学号、成绩
班级类：班级名称、学生列表
显示所有学生
根据学号查找学生
添加一个学生
删除一个学生（学生对象、学号）
根据学号升序排序
根据成绩降序排序
"""
class Student():
def __init__(self,name,age,id,score):
self.__name = name
self.__age = age
self.__id = id
self.__score = score
def __str__(self):
return self.__name + " " + str(self.__age) + " " + str(self.__id) +" " + str(self.__score)
@property
def name(self):
return self.__name
@name.setter
def name(self,name):
self.__name = name
@property
def age(self):
return self.__name
@age.setter
def age(self,age):
self.__age = age
@property
def id(self):
return self.__id
@id.setter
def id(self,id):
self.__id = id
@property
def score(self):
return self.__score
@score.setter
def score(self,score):
self.__score = score
class Class():
def __init__(self,name,stu_list:list):
self.__name = name
self.__stu_list = stu_list
@property
def name(self):
return self.__name
@name.setter
def name(self,name):
self.__name = name
@property
def stu_list(self):
return self.__stu_list
@stu_list.setter
def stu_list(self,stu_list):
self.__stu_list = stu_list
def all_stu(self):
for stu in self.__stu_list:
print(stu)
def select_stu(self,id):
for stu in self.__stu_list:
if stu.id == id:
return stu
return None
def add_stu(self,student):
self.__stu_list.append(student)
def del_stu(self,id):
for stu in stu_list:
if stu.id == id:
self.__stu_list.remove(stu)
def sort_id(self):
for i in range(len(self.__stu_list)-1):
for j in range(len(self.__stu_list)-1-i):
if self.__stu_list[j].id > self.__stu_list[j+1].id:
self.__stu_list[j],self.__stu_list[j+1] = self.__stu_list[j+1],self.__stu_list[j]
self.all_stu()
def sort_score(self):
for i in range(len(self.__stu_list)-1):
for j in range(i+1,len(self.__stu_list)):
if self.__stu_list[i].score < self.__stu_list[j].score:
self.__stu_list[i],self.__stu_list[j] = self.__stu_list[j],self.__stu_list[i]
self.all_stu()
if __name__ == "__main__":
stu1 = Student("小明",20,117,80)
stu2 = Student("小红",29,107,99)
stu3 = Student("小成",22,127,78)
stu4 = Student("小紫",25,118,86)
stu5 = Student("小兰",24,108,84)
stu6 = Student("小亮",22,8,77)
stu_list = []
stu_list.extend([stu1,stu2,stu3,stu4,stu5])
class1 = Class("冲锋班",stu_list)
print(class1.name)
print("++++++++++++++++++")
class1.all_stu()
print("++++++++++++++++++")
class1.add_stu(stu6)
class1.all_stu()
print("++++++++++++++++++")
class1.del_stu(8)
class1.all_stu()
print("++++++++++++++++++")
class1.sort_id()
print("++++++++++++++++++")
class1.sort_score()
五、继承(重点)
1.概念
如果两个或者两个以上的类中具有相同的属性或者方法，我们可以抽取一个类出来，在该类中定义相同的属性或者方法
被抽取出来的类 -----> 父类 超类【super】 基类【base】
两个或者两个以上的类 ------> 子类 派生类
他们之间的关系：子类 继承自 父类
父类 派生了 子类
继承只能继承非私有的，私有只能本类使用
2.单继承
单继承：一个子类只能继承自一个父类
语法：
父类：
class 父类类名(object):
类体【共同的属性或者方法】
子类：
class 子类类名(父类类名):
类体【特有的属性或者方法】
注意：如果一个类没有明确的父类，则默认继承自object
# 1.父类是上帝，上帝定义的属性及方法，所有的类都共同拥有，
# 因为所有的类都直接或者间接的继承了上帝
class ZiMin():
pass
zimin = ZiMin()
print(zimin)
# 2.单继承, 只能继承父类中非私有的属性和方法
class Animal():
def __init__(self,color):
self.color = color
def eat(self):
print("===动物吃====")
class MaoKe(Animal):#继承了动物
def __init__(self,name):
self.name = name
def bu_lie(self):
print("==%s==%s==在捕猎 " % (self.color,self.name))
class Mao(MaoKe):#继承了猫科
def __init__(self,zhuren):
self.zhuren = zhuren
def chi_yu(self):
print("==%s==%s==%s 在吃鱼" % (self.color,self.name,self.zhuren))
if __name__ == "__main__":
mao = Mao("张飞")
mao.name = "张飞家的猫"
mao.color = "黄白"
mao.eat()
mao.bu_lie()
mao.chi_yu()
# 3. 人 name,age
# 学生：学号
# 医生：科室
# 律师：分类
# 在子类构造函数中，一般可以使用super().__init__(name.age)调用父类的构造函数
# 因为自类一般都在父类属性上扩展属性 所有子类属性一般都多于父类
class Person():
def __init__(self,name,age):
self.name = name
self.age = age
def wan(self):
print("===一起摇摆====")
def __str__(self):
return self.name + " " + str(self.age)
class Student(Person):
def __init__(self,name,age,xue_hao):
super().__init__(name,age)
self.xue_hao = xue_hao
def study(self):
print("=====day day up=======")
def __str__(self):
return super().__str__() + " " +self.xue_hao
class Doctor(Person):
def __init__(self,name,age,ke_shi):
super().__init__(name,age)
self.ke_shi = ke_shi
def shou_shu(self):
print("=====冷静做手术======")
def __str__(self):
return super().__str__() + " " + self.ke_shi
class Lawyer(Person):
def __init__(self,name,age,fen_lei):
super().__init__(name,age)
self.fen_lei = fen_lei
def da_guan_si(self):
print("=====为魔鬼歌颂=======")
def __str__(self):
return super().__str__() + " " + self.da_guan_si()
if __name__ == "__main__":
stu1 = Student("燕青",20,"0009")
print(stu1)
stu1.wan()
stu1.study()
print("+++++++++++++++++++")
doc1 = Doctor("扁鹊",40,"全科")
print(doc1)
doc1.shou_shu()
doc1.wan()
print("++++++++++++++++++++")
lay = Lawyer("律师",30,"事故")
lay.wan()
lay.da_guan_si()
"""
构造函数的调用
"""
class Fu():
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return self.name +"----"+str(self.age)
def gong_neng1(self):
print("====fu===功能方法=====")
class Zi(Fu):
pass
class Zi2(Fu):
def __init__(self,name,age,panni):
super().__init__(name,age)#调用父类构造函数
self.panni = panni
def __str__(self):
return super().__str__() +"---"+self.panni
def gong_neng1(self):
print("=====zi-----功能001====")
print("++++++++++++++++++++++++++++++++")
if __name__ == "__main__":
zi1 = Zi("zi001",20)
print(zi1)
zi1.gong_neng1()
print("++++++++++++++++++++++++++++++")
zi2 = Zi2("zi2002",16,"自增属性")
print(zi2)
zi2.gong_neng1()
3.多继承
案例一
"""
多继承
一个类拥有多个父类
可以拥有多个父类的功能
"""
class Runnable():
def __init__(self,name):
self.name = name
def run(self):
print("====%s-==在奔跑====" % self.name)
def __str__(self):
return self.name
class Flyable():
def fly(self):
print("=====翱翔=====")
class Dark(Runnable,Flyable):
def __str__(self):
return super().__str__()
def __init__(self,name):
super().__init__(name)
print("++++++++++++++++++++++++++++++++++")
if __name__ == "__main__":
d1 = Dark("唐老鸭")
print(d1)
d1.run()
d1.fly()
案例2
"""
多继承的2
"""
class Father():
def __init__(self,money):
self.money = money
def work(self):
print("=====一般人都得上班======")
def show(self):
print("====father===show")
def __str__(self):
return self.money
class Mother():
def __init__(self,value):
self.value = value
def guan_money(self):
print("=======花money======")
def show(self):
print("=====mother===show=====")
def __str__(self):
return self.value
class Child(Father,Mother):
def __init__(self,money,value,ziwo):
#super()
Father.__init__(self,money)
Mother.__init__(self,value)
self.ziwo = ziwo
def show(self):
Father.show(self)
Mother.show(self)
print("==================功能扩展=====")
def __str__(self):
return str(Father.__str__(self)) + "---"+Mother.__str__(self)+"----"+self.ziwo
print("+++++++++++++++++++++++++++++++++")
if __name__ == "__main__":
zi = Child(99999,"价值","特有属性")
print(zi)
zi.work()
zi.guan_money()
zi.show()
4.函数的重写
重写：override,在继承关系中，如果在子类中出现了和父类重名的函数，则称为子类重写了父类中的函数
4.1自定义函数的重写
函数的重写 — 子类对父类的功能不满意
1：功能扩展
2：彻底覆盖
class Fu():
def sing(self):
print("=====sing===香水有毒====")
class Zi(Fu):
def sing(self):
supper().sing()#保留父类的功能
print("+++在这个功能上进行扩展===sing ===双节棍")
class Zi2(self):
def sing(self):
print("========sing==孤勇者===")
zi1 = Zi()
zi1.sing()
print("++++++++++++++++++++++")
zi2 = Zi2()
zi2.sing()
六、多态
1.概念
一种事物的多种体现形式，举例：动物有很多种
定义时的类型和运行时的类型不一致，当定义了一个变量，代表某个对象，只有当程序运行的时候，才能确定该变量指向哪个对象，调用哪个函数
注意：继承是多态的前提
作用：有了继承，才能提到多态，在调用类的成员函数的时候，尽量将参数类型视为父类类型，这样，所有的子类类型都可以被正常接收，多态可以起到简化代码的作用
2.使用
"""
一个事物的多种体现形态
"""
class Animal():
pass
class Mao(Animal):
pass
if __name__ == "__main__":
a = Animal()
print(isinstance(a,Animal))#True
print(isinstance(a,Mao))#False
mao = Mao()
print(isinstance(mao,Animal))#True
print(isinstance(mao,Mao))#True
"""
在调用时才可以确定实际类型
"""
class Animal():
def __init__(self,name):
self.name = name
def eat(self):
print("----动物吃===")
class Mao(Animal):
def eat(self):
print("====猫吃鱼====")
class Sheep(Animal):
def eat(self):
print("=====羊吃草====")
class Wolf(Animal):
def eat(self):
print("====狼吃羊=====")
class Person():
def wei_shi(self,animal:Animal):
animal.eat()
print("+++++++++++++++++++++++++++++++++++")
if __name__ == "__main__":
p1 = Person()
mao = Mao("小猫咪")
yang = Sheep("喜羊羊")
wolf = Wolf("红太狼")
p1.wei_shi(mao)
p1.wei_shi(yang)
p1.wei_shi(wolf)
七、获取对象信息
1.type()
- 获取一个变量的类型，返回值为:<class ‘类名’>,属于class类型
2.isinstance()
- 判断一个对象是否属于某种数据类型
3.dir()
- 获取一个类或者对象的属性或者方法，返回值为一个列表
- dir可以随时查看一个对象的信息
print(dir("qq"))
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return self.name + " " + str(self.age)
def fun1(self):
pass
def fun2(self):
pass
p1 = Person("qq",20)
print(p1)
print(dir(p1))
八、类中特殊的成员
1.类属性和成员属性【面试题】
面试题：简述类属性和成员属性的区别
1.定义的位置不同：类属性直接定义在类中，成员属性定义在构造函数中或者动态绑定
2.访问的方式不同：类属性可以使用对象访问，也可以使用类名访问，但是，成员属性只能使用对象访问
3.优先级不同：当类属性和成员属性重名的情况下，使用对象访问优先访问的是成员属性
4.在内存中出现的时机不同：类属性随着类的出现而出现，成员属性随着对象的出现而出现【类属性优先于成员属性在内存中出现】
5.使用场景不同：多个对象共享的数据定义为类属性，每个对象特有的数据定义为成员属性
class Person():
guo_ji = "cn"
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return self.name + "==="+str(self.age)
print("+++++++++++++++++++++++++++++++")
print(Person.guo_ji)
p1 = Person("关羽",20)
print(p1.name)
print(p1.age)
print(p1.guo_ji)
print("+++++++++++++++++++++++++++")
p2 = Person("张飞",18)
print(p2.name)
print(p2.age)
print(p2.guo_ji)
print("+++++++++++++++++++++++++++++++")
Person.guo_ji = "kk"
print(p1.guo_ji)
print(p2.guo_ji)
2.类方法和静态方法【面试题】
面试题：简述成员函数，类函数和静态函数之间的区别
不同点1.是否使用装饰器修饰：使用@classmethod修饰则是类函数，使用@staticmethod修饰则是静态函数，没有任何修饰则是成员函数
2.形参列表不同：
- 成员函数的第一个形参必须为self，类函数的第一个形参必须为cls，
- 静态函数的形参没有要求【self和cls都不是关键字，都可以是普通的标识符，self表示当前的实例，cls表示当前类】
3.调用方式不同：成员函数只能通过对象调用，但是，类函数和静态函数既可以使用对象调用，也可以使用类名调用
4.使用场景不同：如果需要封装工具类，该类中的函数一般采用静态函数或者类函数，但是，如果涉及到对象的操作，一般使用成员函
相同点
1.三者都可以被子类继承，同时也可以在子类中进行重写，子类对象优先调用的是子类中的函数
2.三者都可以使用默认参数，关键字参数，不定长参数
class Person():
def show(self):
print("====这是一个普通方法====")
#类方法
@classmethod
def lei_fun1(cls):
print("====这是一个类方法===")
#静态方法
@staticmethod
def jingtai_fun():
print("====这是一个静态方法===")
print("===静态方法和类方法本质上都属于类，不属于成员===")
if __name__ == "__main__":
Person.lei_fun1()
Person.jingtai_fun()
#Person.show()--不能使用类. 的方式调用成员函数
print("+++++++++++++++++++++++++++++++")
p1 = Person()
p1.show()
"""
一般可以使用静态方法来去实现工具类
math
time
"""
class ListTools():
# 这是一个列表的工具类
# 一般在工具类中提供大的都是静态方法
@staticmethod
def bian_li(list1):
for ele in list1:
print(ele,end=",")
print()
# 求列表的最大值
@staticmethod
def get_max(list1):
max1 = list1[0]
for i in range(len(list1)):
if list1[i] > max1:
max1 = list1[i]
return max1
#进行冒泡排序
@staticmethod
def mao_pao(list1):
for i in range(len(list1)-1):
for j in range(len(list1)-1-i):
if list1[j] > list1[j+1]:
list1[j],list1[j+1] = list1[j+1],list1[j]
if __name__ == "__main__":
list1 = [1,20,333,45,22,78,444]
ListTools.bian_li(list1)
print("++++++++++++++++++++++")
ListTools.mao_pao(list1)
print(list1)
print("++++++++++++++++++++")
max1 = ListTools.get_max(list1)
print(max1)
3.属性
__name__:获取类名字符串,只能通过类名访问
__dict__:返回的结果都是一个字典
- 通过类名访问,获取类的内容，包括成员函数，静态函数和类函数，以及系统函数,类属性
- 通过对象访问，获取对象的内容，包括成员属性
__bases__基类,结果为一个元组，通过类名访问，获取指定类的所有的父类
class Fu():
pass
class Person():
def __init__(self,name):
self.name = name
def show(self):
pass
def show2(self):
pass
def show3(self):
pass
class Stu():
pass
if __name__ == "__main__":
print(Person.__name__)#Person
print(Stu.__name__)#Stu
print("+++++++++++++++++++")
print(Person.__dict__)
print("++++++++++++++++++++")
p1 = Person("qq")
print(p1.__dict__)
print("++++++++++++++++++++++++")
print(Person.__base__)#只显示直接的父类
print(p1.__hash__())#173122810011
九 文件读写
1.写文件
open(path,flag,encoding)
path:要打开的文件的路径【相对路径和绝对路径】
flag：
- r：只读 rb:以只读的方式打开一个二进制文件
- w：写 wb:以写的方式打开一个二进制文件
- a：追加
encoding:编码格式
- utf-8/UTF-8/utf8/UTF8/uTF-8
- gbk/GBK
#1.打开文件
file = open(r"路径","w",encoding="utf8")
print(file)
print("===之前没有就会创建===")
file.write("hello python\n")
file.write("killer is comming\n")
file.flush()#刷新
file.close()
print("+++++++++++++++++++++")
file2 = open(r"文件地址","a",encoding="utf8")# a -- 给文件后面追加
print(file2)
file2.write("today is today")
file2.flush()
file2.close()
print("======over=======")
2. 读文件
read
- read():默认一次性读取指定文件中的全部数据，不管该文件中有多少个字节 文件内容较少
- read(size):一次读取指定size个字节，
readline
- readline():一次只能读取一行，根据换行符判断,只针对文本文件（图片没有行）
- readline(size):一次读取指定size个字节，用法类似read
2.1 读取文本文件
file1 = open(r"文件路径","r",encoding="utf8")#打开文件
print("===open success===")
result = file1.read()#读取动作
print(result)
file1.close()#关闭流
print("++++++++++++++++++++++++")
file2 = open(r"文件路径","r",encoding="utf8")
jieguo1 = file2.read(15)
jieguo2 = file2.read(15)#接着上一次的继续往下读
print(jieguo1)
print(jieguo2)
print("++++++++ readline ++++++++++")
file3 = open(r"文件路径","r",encoding="utf8")
line1 = file3.readline()
line2 = file3.readline()
print(line1)
print(line2)
2.2 读取非文本文件（图片，音频或视频等）
file1 = open(r"文件路径","rb")
result = file1.read()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JaEzQPoB-1679826628527)(C:\Users\11700\AppData\Roaming\Typora\typora-user-images\image-20220520111126082.png)]
3 文件的copy
3.1 拷贝文本文件
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ep4M8Ys-1679826628528)(C:\Users\11700\AppData\Roaming\Typora\typora-user-images\image-20220520111804338.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ecBGCz0N-1679826628528)(C:\Users\11700\AppData\Roaming\Typora\typora-user-images\image-20220520111817206.png)]
3.2 拷贝所有文件
def copy_file(old,new):
du_liu = open(old,"rb")
xie_liu = open(new,"rb")
jieguo = du_liu.read()
xie_liu.write(jieguo)
xie_liu.flush()
du_liu.close()
xie_liu.close()
print("===拷贝完成===")
file1 = r"文件地址"
file2 = r"文件地址"
copy_file(file1,file2)
4. csv文件的读写
4.1 写文件
用csv特有的方式进行写入
newline的默认值为\n,如果不希望每行后面有个空行，则重置newline的值
注意：写入的时候调用csv.writer生成了一个空的可迭代对象 将open的流对象以参数传递给writer，使用writer的返回值对象 进行写行result.writerow(sublist)
import csv
file = open(r"文件路径","w",newline=" ")
result = csv.writer(file)
xie_content = [["qq",20,"man"],["ww",23,"woman"],["ss",30,"man"]]
for i in xie_content:
result.writerow(i)
file.close()
print("=====success=====")
#写一个文件yonghu.py 定义一个用户类
class User:
def __init__(self,name,age,pw):
self.name = name
self.age = age
self.pw = pw
def __str__(self):
return self.name + "--" + str(self.age) + "--" +self.pw
#调用yonghu.py 这个文件
import csv
from day52.yonghu import User
u1 = User("qq",20,"123")
u2 = User("ww",25,"111")
u3 = User("ee",23,"222")
list1 = [u1,u2,u3]
list2 = []
for u in list1:
list = []
list.extend([u.name,u.age,u.pw])
list2.append(list)
file1 = open(r"E:\oo.csv","w",newline="")
result1 = csv.writer(file1)
for user in list2:
result1.writerow(user)
file1.close()
print("===写入成功===")
class YongLi():
def __init__(self,id,name,step,result):
self.id = id
self.name = name
self.step = step
self.result = result
def __str__(self):
return str(self.id) + self.name + self.step + self.result
import csv
file1 = open(r"E:\yong_li.csv","w",newline="")
result = csv.writer(file1)
list_yl = []
for i in range(10):
list = []
yongli = YongLi("00"+str(i),"用例"+str(i),"step"+str(i),"result"+str(i))
list.extend([yongli.id,yongli.name,yongli.step,yongli.result])
list_yl.append(list)
for yl in list_yl:
result.writerow(yl)
file1.close()
print("+++++++++写入成功++++++++++++")
4.2 读文件
import csv
file1 = open(r"E:\oo.csv","r")
result = csv.reader(file1)
for i in result:
print(i)
file1.close()
5. 练习
import os
class FileTools():
@staticmethod
def create_dir(path):
if not os.path.exists(path):
os.mkdir(path)
print("===文件创建成功===")
@staticmethod
def write_file(path,content):
if not os.path.exists(path):
file = open(path,"w")
else:
file = open(path,"a")
file.write(content)
file.flush()
file.close()
@staticmethod
def read_file(path):
file = open(path,"r")
result = file.read()
file.close()
return result
@staticmethod
def get_all_files(path):
if not os.path.exists(path):
print("=====目录不存在=====")
return
if os.path.isfile(path):
print("===文件名 %s ==" % path)
files = os.listdir(path)
for file in files:
file_name = os.path.join(path,file)
if os.path.isfile(file_name):
print("===文件名 %s ==" % file)
result = FileTools.read_file(file_name)
print(result)
else:
FileTools.get_all_files(file_name)
print("+++++++++++++++++++++++++++++++++++")
from day52.filetools import FileTools
if __name__ == "__main__":
FileTools.create_dir(r"E:\qq")
FileTools.create_dir(r"E:\qq\uu")
FileTools.write_file(r"E:\qq\uu\aa.txt","hellow world\n")
result = FileTools.read_file(r"E:\qq\uu\aa.txt")
print(result)
FileTools.get_all_files(r"E:\qq")
类属性
- 通过对象访问，获取对象的内容，包括成员属性
__bases__基类,结果为一个元组，通过类名访问，获取指定类的所有的父类
class Fu():
pass
class Person():
def __init__(self,name):
self.name = name
def show(self):
pass
def show2(self):
pass
def show3(self):
pass
class Stu():
pass
if __name__ == "__main__":
print(Person.__name__)#Person
print(Stu.__name__)#Stu
print("+++++++++++++++++++")
print(Person.__dict__)
print("++++++++++++++++++++")
p1 = Person("qq")
print(p1.__dict__)
print("++++++++++++++++++++++++")
print(Person.__base__)#只显示直接的父类
print(p1.__hash__())#173122810011
九 文件读写
1.写文件
open(path,flag,encoding)
path:要打开的文件的路径【相对路径和绝对路径】
flag：
- r：只读 rb:以只读的方式打开一个二进制文件
- w：写 wb:以写的方式打开一个二进制文件
- a：追加
encoding:编码格式
- utf-8/UTF-8/utf8/UTF8/uTF-8
- gbk/GBK
#1.打开文件
file = open(r"路径","w",encoding="utf8")
print(file)
print("===之前没有就会创建===")
file.write("hello python\n")
file.write("killer is comming\n")
file.flush()#刷新
file.close()
print("+++++++++++++++++++++")
file2 = open(r"文件地址","a",encoding="utf8")# a -- 给文件后面追加
print(file2)
file2.write("today is today")
file2.flush()
file2.close()
print("======over=======")
2. 读文件
read
- read():默认一次性读取指定文件中的全部数据，不管该文件中有多少个字节 文件内容较少
- read(size):一次读取指定size个字节，
readline
- readline():一次只能读取一行，根据换行符判断,只针对文本文件（图片没有行）
- readline(size):一次读取指定size个字节，用法类似read
2.1 读取文本文件
file1 = open(r"文件路径","r",encoding="utf8")#打开文件
print("===open success===")
result = file1.read()#读取动作
print(result)
file1.close()#关闭流
print("++++++++++++++++++++++++")
file2 = open(r"文件路径","r",encoding="utf8")
jieguo1 = file2.read(15)
jieguo2 = file2.read(15)#接着上一次的继续往下读
print(jieguo1)
print(jieguo2)
print("++++++++ readline ++++++++++")
file3 = open(r"文件路径","r",encoding="utf8")
line1 = file3.readline()
line2 = file3.readline()
print(line1)
print(line2)
2.2 读取非文本文件（图片，音频或视频等）
file1 = open(r"文件路径","rb")
result = file1.read()
[外链图片转存中…(img-JaEzQPoB-1679826628527)]
3 文件的copy
3.1 拷贝文本文件
[外链图片转存中…(img-2ep4M8Ys-1679826628528)]
[外链图片转存中…(img-ecBGCz0N-1679826628528)]
3.2 拷贝所有文件
def copy_file(old,new):
du_liu = open(old,"rb")
xie_liu = open(new,"rb")
jieguo = du_liu.read()
xie_liu.write(jieguo)
xie_liu.flush()
du_liu.close()
xie_liu.close()
print("===拷贝完成===")
file1 = r"文件地址"
file2 = r"文件地址"
copy_file(file1,file2)
4. csv文件的读写
4.1 写文件
用csv特有的方式进行写入
newline的默认值为\n,如果不希望每行后面有个空行，则重置newline的值
注意：写入的时候调用csv.writer生成了一个空的可迭代对象 将open的流对象以参数传递给writer，使用writer的返回值对象 进行写行result.writerow(sublist)
import csv
file = open(r"文件路径","w",newline=" ")
result = csv.writer(file)
xie_content = [["qq",20,"man"],["ww",23,"woman"],["ss",30,"man"]]
for i in xie_content:
result.writerow(i)
file.close()
print("=====success=====")
#写一个文件yonghu.py 定义一个用户类
class User:
def __init__(self,name,age,pw):
self.name = name
self.age = age
self.pw = pw
def __str__(self):
return self.name + "--" + str(self.age) + "--" +self.pw
#调用yonghu.py 这个文件
import csv
from day52.yonghu import User
u1 = User("qq",20,"123")
u2 = User("ww",25,"111")
u3 = User("ee",23,"222")
list1 = [u1,u2,u3]
list2 = []
for u in list1:
list = []
list.extend([u.name,u.age,u.pw])
list2.append(list)
file1 = open(r"E:\oo.csv","w",newline="")
result1 = csv.writer(file1)
for user in list2:
result1.writerow(user)
file1.close()
print("===写入成功===")
class YongLi():
def __init__(self,id,name,step,result):
self.id = id
self.name = name
self.step = step
self.result = result
def __str__(self):
return str(self.id) + self.name + self.step + self.result
import csv
file1 = open(r"E:\yong_li.csv","w",newline="")
result = csv.writer(file1)
list_yl = []
for i in range(10):
list = []
yongli = YongLi("00"+str(i),"用例"+str(i),"step"+str(i),"result"+str(i))
list.extend([yongli.id,yongli.name,yongli.step,yongli.result])
list_yl.append(list)
for yl in list_yl:
result.writerow(yl)
file1.close()
print("+++++++++写入成功++++++++++++")
4.2 读文件
import csv
file1 = open(r"E:\oo.csv","r")
result = csv.reader(file1)
for i in result:
print(i)
file1.close()
5. 练习
import os
class FileTools():
@staticmethod
def create_dir(path):
if not os.path.exists(path):
os.mkdir(path)
print("===文件创建成功===")
@staticmethod
def write_file(path,content):
if not os.path.exists(path):
file = open(path,"w")
else:
file = open(path,"a")
file.write(content)
file.flush()
file.close()
@staticmethod
def read_file(path):
file = open(path,"r")
result = file.read()
file.close()
return result
@staticmethod
def get_all_files(path):
if not os.path.exists(path):
print("=====目录不存在=====")
return
if os.path.isfile(path):
print("===文件名 %s ==" % path)
files = os.listdir(path)
for file in files:
file_name = os.path.join(path,file)
if os.path.isfile(file_name):
print("===文件名 %s ==" % file)
result = FileTools.read_file(file_name)
print(result)
else:
FileTools.get_all_files(file_name)
print("+++++++++++++++++++++++++++++++++++")
from day52.filetools import FileTools
if __name__ == "__main__":
FileTools.create_dir(r"E:\qq")
FileTools.create_dir(r"E:\qq\uu")
FileTools.write_file(r"E:\qq\uu\aa.txt","hellow world\n")
result = FileTools.read_file(r"E:\qq\uu\aa.txt")
print(result)
FileTools.get_all_files(r"E:\qq")
1138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
