python
基础知识
python之父：吉多·范罗苏姆（Guido van Rossum）写于：1990
python优点：
1.简单、易学，适应⼈群⼴泛
2. 免费、开源
3. 应⽤领域⼴泛（Google开源机器学习框架：TensorFlow、开源社区主推学习框架：Scikit-learn、百度开源深度学习框架：Paddle）
Python解释器作⽤：运⾏⽂件。解释器种类：CPython、PyPy、Jython
安装python解释器：https://blog.csdn.net/qq_45624685/article/details/119822227
注释：
注释的作用：能够⼤⼤增强程序的可读性。
注释的分类：
单行注释：#注释内容
多行注释：’’’(""")注释内容’’’(""")
Python 中一般以新行作为语句的结束标识，可以使用 \ 将一行语句分为多行显示,如果包含在 []、{}、() 括号中，则不需要使用
a = 128
b = 1024
c = 512
d = a + \
b - \
c
arr = {
a,
b,
c
}
标识符（标识符命名规则是Python中定义各种名字的时候的统⼀规范）：
Python 中标识符由字母(区分大小写)、数字、下划线组成，不能以数字开头，不能与关键字冲突。
以下划线开头的标识符有特殊含义，
单下划线开头的标识符，如：_xxx ，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 导入；
双下划线开头的标识符，如：__xx，表示私有成员；双下划线开头和结尾的标识符，如：xx，表示 Python 中内置标识，如：init() 表示类的构造函数。
编码：
Python2 中默认编码为 ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -- coding: UTF-8 -- 进行指定。
Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码。
数据类型
检测数据类型的⽅法： type()
参数：要检测的数据
返回值：返回数据的类型
a = 1
print(type(a)) # <class 'int'> -- 整型
b = 1.1
print(type(b)) # <class 'float'> -- 浮点型
c = True
print(type(c)) # <class 'bool'> -- 布尔型
d = '12345'
print(type(d)) # <class 'str'> -- 字符串
e = [10, 20, 30]
print(type(e)) # <class 'list'> -- 列表
f = (10, 20, 30)
print(type(f)) # <class 'tuple'> -- 元组
h = {10, 20, 30}
print(type(h)) # <class 'set'> -- 集合
g = {'name': 'TOM', 'age': 20}
print(type(g)) # <class 'dict'> -- 字典
变量
变量：数据在内存中存储之后定义⼀个名称，这个名称就是变量。
定义变量：变量名 = 值
my_name = 'tom'
print(my_name)
schoolName='myname'
print(schoolName)
print格式化输出
%s 字符串
python是一门弱类型语言，不论什么类型的数据都可以输出字符串。
%d 有符号的十进制整数
%03d表示整数显示3位数，不足以0补全，超出当前位数原样输出。
%f 浮点数(默认保留6位小数，可以加上%.3f保留3位小数)
%c 字符
%u 无符号二进制
%o 八进制整数
%x 十六进制整数(小写ox)
%X 十六进制整数（大写OX）
%e 科学计数法（小写e）
%E 科学计数法（大写E)
%g %f和%e的简写
%G %f和%E的简写
'''
格式化输出数据。
1.准备数据。
2.格式化符号输出数据。
'''
age = 18
name = 'tom'
weight = 75.5
stu_id = 1
stu_id2 = 1000
# 1.今年我的年龄是x岁 -- 整数 %d
print('今年我的年龄是%d岁'%age)
#2.我的名字是X -- 字符串 %S
print("我的名字是%s"%name)
#3.我的体重是x公斤-- 浮点数 %f
print("我的体重是%.3f" %weight)
#4.我的学号是x -- %d
print("我的学号是%d" %stu_id)
#4.1我的学号是001 -- %
print("我的学号是%03d" %stu_id)
print("我的学号是%03d" %stu_id2)
#5.我的名字是x，今年x岁了
print("我的名字是%s，今年%d岁了" %(name,age))
# 5.1我的名字是x，明年x岁了
print("我的名字是%s，今年%d岁了" %(name,age+1))
#6.我的名字是x，今年x岁了，体重x公斤，学号是x
print("我的名字是%s，今年%d岁了，体重%.3f公斤，学号是%03d"%(name,age,weight,stu_id))
f’{表达式}‘也是格式化字符串与%s一样的效果
f’{表达式}‘比%s更高效
f’{表达式}'是3.6后的版本新增的。
name = 'tom'
age =18
#我的名字是x，今年x岁了
print("我的名字是%s,今年%s岁了"%(name,age))
#语法：f'{表达式}'
print(f'我的名字是{name},今年{age}岁了')
转义字符
\n换行 \t制表符，一个tab键（4个空格)的距离。
print('hello world')
print('hello\npython')
print('\tabcd')
结束符
python中的print()默认带一个end="\n",所以会换行。
end=""
print('hello',end="\t")
print('world')
输入
在Python中，程序接收⽤户输⼊的数据的功能即是输⼊。
语法：input(“提示信息”)
input特点：
1.当程序执行到input的时候，等待输入，当输入后，才会继续执行。
2.一般将input输入的内容存储为变量
3.input接收到的数据是字符串
'''
1.书写input
input('提示信息')
2.特点
1.遇到input,等待用户输入
2.一般将input输入的内容存储为变量
3.input接收到的数据类型都是字符串
'''
password = input('请输入您的密码:')
print(f'您输入的密码是{password}')
print(type(password))#<class 'str'>
转换数据类型
转换数据类型的函数
int(x[,base]):将x转换成一个整数。
oct(x):将一个整数转换成一个八进制字符串
hex(x):将一个整数转换成要给十六进制字符串
float(x):将x转换为一个浮点数
str(x):将对象x转换为字符串。
tuple(s):将序列s转换为一个元组
list(s):将序列s转换为一个列表
eval(str):用来计算在字符串中的有效python表达式，并返回一个对象。
complex(real[,imag]):创建一个复数，real为实部，imag为虚部
repr(x):将对象转换为表达式字符串
chr(x)：将一个整数x转换为一个unicode字符
ord(x):将一个字符转换为它的ascii整数值。
#int(x[,base])：将括号内的内容转换成整数,base代表括号内的内容是几进制
print(int('1'))
print(type(int('1')))#<class 'int'>
print(int('12',8))#10
#oct():将括号内的内容转换成八进制字符串
print(oct(22))#0o26
print(type(oct(22)))#<class 'str'>
#hex()：将括号内的内容转换成十六进制字符串
print(hex(44))#0x2c
print(type(hex(44)))#<class 'str'>
#float()将括号内的对象转换为一个浮点数
print(float(1))#1.0
print(type(float(1)))#<class 'float'>
#str()将括号内的对象转换成一个字符串
print(str(1))#1
print(type(str(1)))#<class 'str'>
#char():将括号内的整数转换为一个unicode字符
print(chr(65))#A
print(type(chr(65)))#<class 'str'>
#ord():将括号内的字符转换为一个整数
print(ord('A'))#65
print(type(ord('A')))#<class 'int'>
#tuple():将括号内的序列转换成一个元组
print(tuple([10,20,30]))#(10, 20, 30)
print(type(tuple([10,20,30])))#<class 'tuple'>
#list():将括号内的序列转换成一个列表
print(list([1,2,3]))#[1, 2, 3]
print(type(list([1,2,3])))#<class 'list'>
#complex(real[,imag]):创建一个复数real为实部,imag为虚部
print(complex(1,2))
print(type(complex(1,2)))
#repr():将对象转换成表达式字符串
print(repr('aaa'))#'aaa'
print(type(repr('aaa')))#<class 'str'>
#eval():用来计算在字符串中的有效python表达式,并返回对应的类型
#eval()就是把字符串里面的数据转换成他本来的数据类型
str2 = '1'
str3 = '1.1'
str4 = '(1000,2000,3000)'
str5 = '[1000,2000,3000]'
print(type(eval(str2)))#<class 'int'>
print(type(eval(str3)))#<class 'float'>
print(type(eval(str4)))#<class 'tuple'>
print(type(eval(str5)))#<class 'list'>
'''
1.input
2.检测input数据类型
3.int()转换数据类型
4.检测是否转换成功
'''
num = input('请输入数字')
print(num)
print(type(num))
print(type(int(num)))
运算符
1、算数运算符
| 运算符 | 描述 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| // | 整除 |
| % | 取余 |
| ** | 指数 |
| () | 小括号 |
注意：混合运算优先级()高于** 高于*，/高于+-
#整数相加/减/乘/指数只能产生整数，如果有浮点数参与就会生产浮点数
print(1+1)#2
print(1+1.0)#2.0
print(1-1)#0
print(1-0.5)#0.5
print(2*3)#6
print(2*0.5)#1.0
print(2**3)#8
print(2**3.0)#8.0
#除参与的运算只会产生浮点数
print(4/2)#2.0
#整除只会产生整数
print(9//4)#2
print(1+2*3)#7
print((1+2)*3)#9
print(2*3**2)#18
2、 赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | (赋值) | 将等号右边的值赋值给等号左侧的变量 |
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c- a |
| *= | 乘法赋值运算符 | c *= a 等价于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| //= | 整除赋值运算符 | c //= a 等价于 c = c // a |
| %= | 取余赋值运算符 | c %= a 等价于 c = c % a |
| **= | 幂赋值运算符 | c ** = a 等价于 c = c ** a |
#单个变量赋值
num = 1
print(num)#1
#多个变量赋值等号左边的数量和等号右边的数量相等
num2,float1,str1 = 10,0.5,'hello world'
print(num2)#10
print(float1)#0.5
print(str1)#hello world
#多变量赋相同的值
a=b=10
print(a)#10
print(b)#10
a=20
print(a)#20
print(b)#10
a = 10
a += 1 #a = a+1
print(a)
b=10
b -= 1
print(b)
c = 10
c += 1 + 2
print(c)#13
#先算复合赋值右边的表达式，再算复合赋值表达式。
d = 10
d *= 1 + 2
print(d)
3、比较运算符
结果是布尔类型
| 运符 | 描述 |
|---|---|
| == | 判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False) |
| != | 不等于 。如果两个操作数的结果不相等，则条件为真(True)，否则条件结果为假(False) |
| > | 运算符左侧操作数结果是否⼤于右侧操作数结果，如果⼤于，则条件为真，否则为假 |
| < | 运算符左侧操作数结果是否⼩于右侧操作数结果，如果⼩于，则条件为真，否则为假 |
| >= | 运算符左侧操作数结果是否⼤于等于右侧操作数结果，如果⼤于，则条件为真，否则为假 |
| <= | 运算符左侧操作数结果是否⼩于等于右侧操作数结果，如果⼩于，则条件为真，否则为假 |
a = 7
b = 5
print(a == b)#False
print(a != b)#True
print(a < b)#False
print(a > b)#True
print(a <= b)#False
print(a >= b)#True
4、逻辑运算符
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 布尔"与"：如果 x 为 False，x and y 返回False，否则它返回 y 的值。 |
| or | x or y | 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。 |
| not | not x | 布尔"⾮"：如果 x 为 True，返回 False 。如果 x为 False，它返回 True。 |
a = 0
b = 1
c = 2
# and 与：一假为假
print(a < b and b<c)#True
print(a > b and c<b)#False
#or 或：一真为真
print(a<b or c>b)#True
print(a>b or c>b)#True
#3.not :非
print(not False)#True
print(not (a>b))#True
#数字之间的逻辑运算
a = 0
b = 1
c = 2
#and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
print(a and b)#0
print(b and a)#0
print(a and c)#0
print(c and a)#0
print(b and c)#2
print(c and b)#1
#or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
print(a or b)#1
print(a or c)#2
print(b or c)#1
5、位运算符
按位运算符是把数字看作二进制来进行计算的
| 运算符 | 实例 | 描述 |
|---|---|---|
| & | a & b | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
| | a |b | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 |
| ^ | a ^ b | 按位异或运算符：当两对应的二进位相异时，结果为1。 |
| ~ | ~a | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。 |
| << | a << 3 | 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 |
| >> | a >> 3 | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 |
a = 60#0011 1100
b = 13#0000 1101
print(a & b)#00001100:12
print(a | b)#00111101:63
print(a ^ b)#00110001:49
print( ~ b)#11110010-14
print(a << 2)#1111 0000:240
print(a >> 2)#0000 1111:15
条件判断
if
格式：
if 条件:
语句体
'''
if 条件:
条件成立执行的代码
...
'''
#if True:
if False:
print("条件成立时的代码")
print("条件成立时的代码2")
#注意：在这个下方的没有缩进的代码，不属于if语句块，即和条件的成立与否无关。
print("这个代码执行吗?")
实例：网吧上网，简单版
#分析：年龄大于等于18，输出:已经成年，可以上网--准备年龄的数据和18做比较
age = 20
if age>=18:
print("已经成年，可以上网")
print("系统关闭")
#网吧上网进阶版
#系统可以输入用户年龄，用这个年龄做条件判断
'''
1.用户输入
2.保存用户输入的年两
3.if
'''
#input输入的是字符串，要使用int强制类型转换。
age = int(input("请输入你的年龄"))
if age >= 18:
print(f'您输入的年龄是{age},已经成年，可以上网')
#print("您的年龄是%s,已经成年，可以上网"%age)
print("系统关闭")
if … else…
格式：
if 条件:
条件成立执行的代码
else:
条件未成立时执行的代码
#网吧上网实用版
age = int(input("请输入你的年龄"))
if age >= 18:
print(f'您输入的年龄是{age},已经成年，可以上网')
else:
print(f'您输入的年龄是{age},未成年，不可以上网')
pycharm打断点
多重判断
语法:
if 条件1:
条件1成立执行的代码
elif 条件2:
条件2成立执行的代码
else:
以上条件都不成立执行的代码。
#多重判断
'''
需求：
如果年龄小于18，为童工，不合法
如果年龄18-60岁之间，为合法工作年龄
如果年龄大于60为退休年龄
'''
'''
步骤：
1.用户输入自己的年龄，保存变量--str
2.if做判断，elif
3.输出提示信息：您输入的年龄是x，合法与否
'''
age = int(input("请您输入您的年龄"))
if age<18:
print(f'您输入的年龄是{age}，不合法')
elif age<60:
print(f'您输入的年龄是{age}，合法')
else:
print(f'您输入的年龄是{age}，已退休，不合法')
python扩展：化简写法
age = int(input("请输入您的年龄"))
if age<18:
print(f"您的年龄是{age},童工一枚")
#elif (age >= 18) and (age<=60):
elif 18 <= age <=60:
print(f"您的年龄是{age},合法工龄")
elif age>60:
print(f"您的年龄是{age},可以退休")
if嵌套
一个大的if里面包含一个小的if
语法：
if 条件1:
条件1成立的代码
if 条件2:
条件2成立的代码
#坐公交：如果有钱就可以上车，没有钱，不能上车；如果上车了，判断能否坐下。
'''
1.判断将来要判断的数据：钱和空座
2.判断是否有钱：上车和不能上车
3.上车了：判断是否能坐下，有空座位和无空座位。
'''
money = 1
seat = 0
if money == 1:
print("土豪，请上车")
#判断是否能坐下
if seat == 1:
print("有空座，坐下了")
else:
print("没有空座，站着等...")
else:
print("朋友，没带钱，跟着跑，跑快点")
'''
1.出拳
玩家：手动输入
电脑：1.固定：剪刀；2.随机
2.判断输赢
2.1玩家获胜
2.2平局
2.3电脑获胜
'''
#1.出拳
#玩家
player = int(input("请出拳：0-石头；1--剪刀；2--布"))
#电脑
computer = 1
#2.判断输赢
#玩家获胜
if((player==0)and(computer==1))or((player==1)and(computer==2))or((player==2)and(computer==0)):
print("玩家获胜，哈哈哈")
#平局
elif player == computer:
print("平局，别走，再来一局")
#电脑获胜
else:
print("电脑获胜，你个小垃圾")
随机数
获取随机数的步骤
1.导入random模块：import 模块名
2.使用random模块中的随机整功能：random,randint(开始，结束)
'''
1.出拳
玩家：手动输入
电脑：1.固定：剪刀；2.随机
随机：1.导入模块，2.使用这个模块的功能
2.判断输赢
2.1玩家获胜
2.2平局
2.3电脑获胜
'''
import random
#1.出拳
#玩家
player = int(input("请出拳：0-石头；1--剪刀；2--布"))
#电脑
computer = random.randint(0,2)#0,1,2
#2.判断输赢
#玩家获胜
if((player==0)and(computer==1))or((player==1)and(computer==2))or((player==2)and(computer==0)):
print("玩家获胜，哈哈哈")
#平局
elif player == computer:
print("平局，别走，再来一局")
#电脑获胜
else:
print("电脑获胜，你个小垃圾")
三目运算符
作用：化简简单的判断句的代码量
格式：条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
a = 1
b = 2
c = a if a>b else b
print(c)#2
#需求：有两个变量，比较大小如果变量1大于变量2执行变量1-变量2，否则变量2-变量1
aa = 10
bb = 6
cc = aa-bb if aa>bb else bb-aa
print(cc)#4
循环
while循环
格式：
while 条件：
条件成立要重复执行的代码
#需求：重复打印5次媳妇我错了
i=0;
while i<5:
print("媳妇我错了")
i += 1 # i= i+1
#需求：1-100数字累加和
'''
1+2+3+4...+100
1.准备做加法运算的数据1-100
2.准备变量保存将来运算的结果
3.循环做加法运算
4.打印结果
5.验证结果正确性
'''
#准备数据
i = 1
#结果变量
result = 0
#循环
while i <= 100:
#加法运算，前两个数的结果+第三个数字，每计算一次加法则更新一次result的结果
result = result + i
i += 1
#打印最终结果
print(result)
#需求：1-100内的偶数和2+4+6.。。+100
#方法一：条件判断余数0
'''
1.准备累加的数字 开始1 结果100 增量2
2.准备保存结果的变量result
3.循环加法运算-- 如果是偶数才加法运算--
4.输出结果
5.验证结果
'''
i=1
result=0
while i<=100:
#条件语句 -- if
if i%2==0:
result += i
i += 1
print(result)#2550
#需求：1-100内的偶数和2+4+6.。。+100
#计数器控制增量为2实现
'''
1.准备累加的数字 开始1 结果100 增量2
2.准备保存结果的变量result
3.循环计算
4.输出结果
5.验证结果
'''
i=1
result=0
while i<=100:
result += i
i += 2
print(result)#2550
break 和 continue
#break:当某些条件成立，退出整个循环
#循环吃5个苹果，吃完第三个吃饱了，第4个和第5个不吃了（不执行)
i = 1
while i<=5:
#条件：吃完第三个吃饱了，第4个和第5个不吃了（不执行)
if i==3:
print("吃饱了，不吃了")
break
print(f'吃了第{i}个苹果')
i += 1
#continue:退出当前循环，继续下一层循环。
#吃了5个苹果 -- 循环，吃到第3个吃出了一条虫子，继续吃第4个，第5个苹果
i = 1
while i <= 5:
#条件
if i==3:
print("吃出了一个大虫子，这个苹果不吃了")
#如果使用了continue,在continue之前一定要更改计数器，否则死循环
i+=1
continue
print(f"吃第{i}个苹果")
i += 1
循环嵌套
一个while里面在嵌套一个while
'''
1.循环打印3次媳妇，我错了
2.今天刷晚上的碗
'''
j = 0
while j < 3:
i = 0
while i < 3:
print("媳妇，我错了")
i += 1
print("刷晚饭的碗")
print("一套惩罚结束...")
j += 1
需求1：
#正方形
'''
1.打印一个星星
2.一行五个，循环 -- 5个星星在一行显示
3.打印5行星星：循环 -- 一行5个
'''
j = 0
while j<5:
i = 0
while i<5:
print("*",end=" ")
i += 1
print()
j += 1
#三角形：每行星星的个数和行数相等
j = 0
while j<5:
i = 0
while i<=j:
print("*",end=" ")
i += 1
print()
j += 1
#打印99乘法表
'''
先分析由什么组成，再由简单到复杂。
由什么组成x * x =x*x
1.打印一个乘法表达式
2.一行打印多个表达式 -- 一行表达式的个数和行号数相等
3.打印多行表达式
'''
j=1
while j<=9:
#一行的表达式
i = 1
while i<=j:
print(f'{i}*{j}={i*j}',end="\t")#\t用于一位数和二位数对不起的问题
i += 1
print()
j += 1
while和else联合使用
else当循环正常结束后要执行的代码。
#需求:道歉5遍媳妇我错了，完成之后执行媳妇原谅我了
'''
1.书写道歉的循环
2.循环正常结束要执行的代码
'''
i = 1
while i <= 5:
print("媳妇我错了")
i += 1
else:
print("媳妇原谅我了")
#while和else
i = 1
while i <= 5:
if i == 3:
break
print("媳妇我错了")
i += 1
else:
print("媳妇原谅我了，真开心")
'''
媳妇我错了
媳妇我错了
'''
#while和continue
i = 1
while i <= 5:
if i == 3:
i += 1
continue
print("媳妇我错了")
i += 1
else:
print("媳妇原谅我了，真开心")
'''
媳妇我错了
媳妇我错了
媳妇我错了
媳妇我错了
媳妇原谅我了，真开心
'''
for和else
#for 和 else
str1 = 'itheima'
for i in str1:
print(i)
else:
print("循环正常结束执行的else的代码")
#for 和 else 和break/continue
str1 = 'itheima'
for i in str1:
if i=='e':
continue
#break
print(i)
else:
print("循环正常结束执行的else的代码")
for 循环
一个数据，数据内部有多个数据组成，这样的一个数据我们就叫它数据序列,for 循环可以遍历任何序列。
格式：
for 临时变量 in 序列:
重复执行的代码
# for体验
'''
for 临时变量 in 序列:
重复执行的代码
'''
'''
1.准备一个数据序列
2.for
'''
str1 = 'itheima'
for i in str1:
print(i)
# for中break
'''
for 临时变量 in 序列:
重复执行的代码
'''
'''
1.准备一个数据序列
2.for
'''
str1 = 'itheima'
for i in str1:
if i == 'e':
print("遇到e不打印")
break
print(i)
# for中continue
'''
for 临时变量 in 序列:
重复执行的代码
'''
'''
1.准备一个数据序列
2.for
'''
str1 = 'itheima'
for i in str1:
if i == 'e':
print("遇到e跳过")
continue
print(i)
字符串
python按照数据是否可以改变划分为 可变数据类型和不可变类型，字符串属于不可变数数据类型。
什么是字符串？
引号引起来的就是字符串
转义字符：
| 转义字符 | 描述 |
|---|---|
| \ | 在行尾使用时，用作续行符 |
| \b | 退格（Backspace） |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
r/R:r/R后的字符串原样输出
#字符串
a = 'hello world'
b = "hello world"
c = '''hello world'''
d=""""""
#第二个'是一个转义字符
f='i\'m tom'
print(type(a))
print(type(b))
print(type(c))
print(type(d))
字符串输出
#字符串输出
print("hello world")
name = "Tom"
print('我的名字是%s'%name)
print(f'我的名字是{name}')
字符串输入
input()用户输入的数据
#字符串输入
passwd = input("请输入你的密码")
print(f"你的密码是{passwd}")
print(type(passwd))
下标：下标又叫索引，就是编号
下标的作用即是通过下标快速找到对应的数据
#下标
str1 = 'abcdefg'
print(str1)
#程序在运行过程中存储在内存中
#得到字符串中的某个字符
#这些字符数据从0开始顺序分配一个编号 -- 使用这个编号精确找到某个字符 -- 下标或索引，索引值
#str1[下标]
print(str1[0])
print(str1[1])
切片：切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作。
#切片
str1 = 'abcdefg'
#得到整个字符串数据
print(str1)
#得到abc
#序列[开始位置下标:结束位置下标:步长]
#下标位置对应的数据，
#步长可以省略默认为1
print(str1[0:5])#abcde
print(str1[:5])#如果不写开始，默认为0
print(str1[2:])#如果不写结束，默认到-1
print(str1[-4:-1])#可以写负数
print(str1[0:5:2])#ace
#如果步长为负数，表示倒叙选取
#如果选取方向（下标开始到结束的方向）和步长的方向冲突，则无法选取数据
print(str1[-4:-1:-1])#
print(str1[-1:-4:-1])#gfe
字符串常用操作方法
查找：查找子串在字符串中的位置或出现的次数
find():用处；检测某个子串是否包含在这个字符串中。
参数：子串和查找的位置(可以省略）
返回值：如果在返回这个子串开始的下标，否则返回-1
rfind():与find()相同，但查找方向从右网左
格式：字符串序列.find(子串,开始位置下标，结束位置下标）
index():检查某个子串是否包含在这个字符串中
参数：子串和查找的位置(可以省略）
如果在返回这个子串开始的位置下标，否者报异常。
格式：字符串序列.index(子串，开始位置下标，结束位置下标)
rindex():与index()相同但查找方向为右侧开始。
count():功能：获取子串在字符串中出现的次数
参数：子串和查找的位置(可以省略）
返回值：返回某个子串在字符串中出现的次数
格式：字符串序列.count(子串，开始位置下标，结束位置下标）
#查找
mystr = "hello world and fuyihao and Python and my_girl"
#1.find()
print(mystr.find('and'))#12
print(mystr.find('and',15,30))#23
print(mystr.find('ands'))#-1
#2.index()
print(mystr.index('and'))#12
print(mystr.index('and',15,30))#23
#print(mystr.index('ands'))#报错
#3.count()
print(mystr.count('and'))#3
print(mystr.count('and',15,30))#1
#4.rfind()
print(mystr.rfind('and'))#35
#5.rindex()
print(mystr.rfind('and'))#35
修改：通过函数的形式修改字符串中的数据
replace():替换
参数：字符串序列.replace(旧子串,新子串,替换次数)
替换次数如果查出子串出现次数，则替换次数为该子串出现次数，替换次数大于字符次数，则替换所有
返回值：替换后的字符串，字符串是不可变类型，字符串不能改变
split():分割
参数：字符串序列，split(分割字符，替换次数）
返回值：返回一个列表，列表内数据个数：替换次数+1 丢失分割字符，
join():合并列表里的字符串数据为一个大字符串
参数：字符或子串.join(多字符串组成的序列)
返回值：字符串
#替换
mystr = 'hello world and fuyihao and Python and my_girl'
#replace()
print(mystr.replace('and','he'))
print(mystr.replace('and','he',1))#只替换一次
print(mystr.replace('and','he',10))
#split()
print(mystr.split('and'))
print(mystr.split('and',2))
#join()
mylist=['aa','bb','cc']
print('...'.join(mylist))#aa...bb...cc
字母大小写
capitalize():将字符串第一个字符转换为大写
参数：无
返回值：字符串
title():字符串中每个单词都是大写
参数：无
返回值：字符串
upper:小写转大写，所有的字母
参数：无
返回值：字符串
lower():大写转小写，所有字母
参数：无
返回值：字符串
mystr = 'hello world and fuyihao and Python and my_girl'
#1.capitalize()字符串首字母大写
print(mystr.capitalize())
#2.title():字符串中每个单词都是大写
print(mystr.title())
#3.upper()
print(mystr.upper())
#4.lower()
print(mystr.lower())
删除空格
lstrip:删除字符串左侧空白字符
参数：无
返回值：字符串
rstrip:删除字符串右侧空白字符
参数：无
返回值：字符串
strip:删除字符串两侧空白字符
参数：无
返回值：字符串
mystr = ' hello world and fuyihao and Python and my_girl '
#1.lstrip()
print(mystr.lstrip())
#2.rstrip()
print(mystr.rstrip())
#3.strip()
print(mystr.strip())
对齐：设置字符串左右对齐方式
ljust():返回一个原字符串左对齐，并使用指定字符(默认空格)填充至对于滚长度的新字符串
参数：字符串序列.ljust(长度，填充字符)
返回值：无
rjust():返回一个原字符串右对齐，并使用指定字符(默认空格)填充至对于滚长度的新字符串
参数：字符串序列.rjust(长度，填充字符)
返回值：无
center():返回一个原字符居中对齐，并使用指定字符(默认空格)填充至对于滚长度的新字符串
参数：字符串序列.center(长度，填充字符)
返回值：无
>>> mystr = 'hello'
>>> mystr
'hello'
>>> mystr.ljust(10)
'hello '
>>> mystr.ljust(10,'.')
'hello.....'
>>> mystr.ljust(10,'.')
'hello.....'
>>> mystr.rjust(10)
' hello'
>>> mystr.rjust(10,'.')
'.....hello'
>>> mystr.center(10)
' hello '
>>> mystr.center(10,'.')
'..hello...'
判断：即是真假返回的结果是布尔类型数据
startswith():检查字符串是否以自定子串开头，是则返回True，否则返回False，如果设置开始和结束位置下标，则在指定范围内检查
参数：字符串序列.startswith(子串，开始位置下标，结束位置下标)
返回值：布尔值
endswith():检查字符串是否以自定子串结尾，是则返回True，否则返回False，如果设置开始和结束位置下标，则在指定范围内检查
参数：字符串序列.endswith(子串，开始位置下标，结束位置下标)
返回值：布尔值
mystr = 'hello world and fuyihao and Python and my_girl'
#1.startswith()
print(mystr.startswith("hello"))#True
print(mystr.startswith("hell0s"))#False
#2.endswith()
print(mystr.endswith("Python"))#True
print(mystr.endswith("hell0s"))#False
isapha():如果字符串至少有一个字符并且所有字符都是字母则返回True,否则返回False
isdigit():如果字符串只包含数字则返回True,否则返回False
isalnum():如果字符串至少有一个字符并且所有字符都是字母或数字则返回True否者返回False
isspace():如果字符串中包含空白，则返回True,否则返回False
mystr = 'hello world and fuyihao and Python and my_girl'
#1.isalpha():字母
print(mystr.isalpha())#False
#2.isdigit():数字
print(mystr.isdigit())#False
#3.isalnum():字母或字母或组合
print(mystr.isalnum())#False
#4.isspace():空白
print(mystr.isspace())#False
列表
列表为可变类型，列表是序列结构，可以进行序列结构的基本操作
存储多个数据，可以为不同类型
格式：[数据1，数据2，数据3，数据]
列表的常用操作
增：增加指定数据到列表中
列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型数据。
1.append()函数
name_list = ['tom','lily','rose']
print(name_list.append('xiaoming'))#None
#append函数追加数据的时候如果数据是一个序列，追加整个序列到列表的结尾
name_list.append([11,22])
print(name_list)
2.extend():列表结尾追加数据，如果数据是一个序列， 则将这个序列的数据一一添加到列表
语法：列表序列.extend(数据)
name_list = ['tom','lily','rose']
name_list.extend('xiaoming')
name_list.extend(['xiaoming','xiaohong'])
print(name_list)
3.insert():指定位置新增数据
语法：列表序列.insert(位置下标，数据)
name_list = ['tom','lily','rose']
#insert(位置，数据)
name_list.insert(1,'aaa')
print(name_list)
删
删除列表
1.格式：del 目标 或 del(目标)
删除指定的数据
2.pop():删除指定下标的数据（默认为最后一个），并返回该数据
语法：列表序列.pop(下标)
3.remove():移除列表中某个数据的第一个匹配项。
语法：列表序列.remove(数据)
4.clear():清空列表
name_list = ['tom','lily','rose']
#1.del
#del name_list
#del(name_list)
#del可以删除指定下标的数据
#del(name_list[0])
print(name_list)
#pop():删除指定下标的数据，如果不指定下标，默认删除最后一个数据，返回被删除的数据
#print(name_list.pop())
print(name_list)
#remove(数据)
#print(name_list.remove('tom'))#None
#print(name_list)
#clear()
name_list.clear()
print(name_list)
改
修改指定下标的数据
1.逆置：reverse()
2.排序：sort()
格式：列表序列.sort(key=None,reverse=False)
reverse表示排序规则，True降序，False排序（默认）
3.复制:函数：copy()
name_list = ['tom','lily','rose']
#1.修改指定下标的数据
name_list[0]='aaa'
print(name_list)
#逆序reverse()
list1=[1,3,2,5,4,6]
list1.reverse()
print(list1)
#sort()排序：升序和降序
list1.sort()
#list1.sort(reverse=True)
print(list1)
#copy()赋值列表
name_list = ['tom','lily','rose']
name_copy = name_list.copy()
print(name_copy)
查
1.下标定义：计算机内存分配的从0开始的一个编号，为的是按下标可以找到针对性的数据。
name_list = ['tom','lily','rose']
print(name_list)
print(name_list[0])
print(name_list[1])
print(name_list[2])
2.查找函数：
index()和count()与字符串中的用法一样
2.1、index():返回指定数据所在位置的下标
语法：列表序列.index(数据，开始位置下标，结束位置下标)
2.2、count():统计指定数据在当前列表中出现的次数。
2.3、len():访问列表长度，即列表中的数据个数。
name_list = ['tom','lily','rose']
#index()
print(name_list.index('tom'))#0
#print(name_list.index('toms'))#报错
print(name_list.index('tom',0,2))
#count()
print(name_list.count('tom'))#1
print(name_list.count('toms'))#0
#len()
print(len(name_list))#3
2.4判断是否存在，一判断返回值就是布尔类型
in ：判断指定数据在某个列表序列，如果在True,如果不在False
not in :判断指定数据不在某个列表序列，如果不在False，如果在True
name_list = ['tom','lily','rose']
#1.in
print('tom' in name_list)#True
print('toms' in name_list)#False
#2.not in
print('toms' not in name_list)#True
print('tom' not in name_list)#False
#in/not in案例
'''
需求：注册邮箱，用户输入一个账号，判断这个账号是否存在，
如果存在，提示用户否则提示可以注册
1.用户输入账号
2.判断if。。。else。。。
'''
name_list = ['tom','lily','rose']
name = input("请输入您的邮箱账号名")
if name in name_list:
#提示用户名已经存在
print(f"您输入的名字是{name},此用户名已经存在")
else:
#提示可以注册
print(f"您输入的名字是{name},可以注册")
循环输出列表内容。
'''
1.准备表示下标数据
2.循环while
条件 i < 3 len()
遍历：依次按循环访问到序列的每一个数据
i += 1
'''
name_list = ['tom','lily','rose']
i=0
while i < len(name_list):
print(name_list[i])
i += 1
#for循环
name_list = ['tom','lily','rose']
for i in name_list:
#遍历序列中的数据
print(i)
列表嵌套
一个列表里面包含了其他的子列表
name_list=[['tom','lily','rose'],['张三','李四','王五'],['xiaomign','xiaolu']]
print(name_list)
print(name_list[0])
print(name_list[0][1])
案例：
#需求：8位老师，3个办公室，将8个老师随机分配到3个办公室
'''
步骤
1.准备数据
1.1.8位置老师 -- 列表
1.2. 3个办公室 -- 列表嵌套
2.分配老师到办公室
随机分配
就是把老师的名字写入到办公室列表--办公室列表追加老师名字
3.验证是否分配成功
打印办公室详细信息：每个办公室的人数和型对应的老师名字
'''
import random
#1.准备数据
teachers = ['A','B','C','D','E','F','G','H']
offices = [[],[],[]]
#2.分配老师到办公室
for name in teachers:
#列表追加数据 -- append,extend,insert
#xx[0] -- 不能只当是具体某个下标 -- 随机
num = random.randint(0,2)
offices[num].append(name)
#为了更贴合生活，把每个办公室子列表加一个办公编号1，2，3
i=1
#3.验证是否分配成功
for office in offices:
#打印办公室的人数--子列表数据的个数 len()
print(f"办公室{i}的人数是{len(office)},老师分别是:")
#打印老师的名字
#每个子列表里面的名字个数不一定 -- 遍历 -- 子列表
for name in office:
print(name,end="\t")
print()
i += 1
元组
一个元组可以存储多个数据，元组内的数据是不能修改的。
元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型
#元组
#多个数据元组
t1 = (10,20,30)
print(t1)
print(type(t1))
#单个数据元组
#如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的。
t2 = (10,)
print(t2)
print(type(t2))
元组的查找
1.按下标查找数据
2.index():查找某个数据，如果数据存在返回对应的下标，否则报错。
3.count():统计某个数据在当前元组出现的次数
4.len()统计元组中的数据个数
t1 = ('aa','bb','cc','bb')
#1.下标
print(t1[0])
#2.index()
print(t1.index('bb'))#1
#3.count()
print(t1.count('bb'))#2
#4.len()
print(len(t1))#4
t1 = ('aa','bb','cc','bb')
#t1[0] = 'aaa'#报错
t2 = ('aa','bb',['cc','dd'])
t2[2][0]='tom'
print(t2)
字典
字典为可变类型
字典是以键值对形式出现，字典数据和数据顺序没有关系，字典不支持下标
字典特点：
符号为大括号
数据为键值对形式出现
各个键值对之间用逗号隔开
#{}键值对 各个键值对用逗号隔开
#有数据字典
#⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。
dict1 = {'name':'Tom','age':20,'gender':'男'}
print(dict1)
print(type(dict1))#<class 'dict'>
#空字典
dict2={}
print(type(dict2))#<class 'dict'>
dict3 = dict()
print(type(dict3))#<class 'dict'>
增
写法：字典序列[key] = 值
如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
dict = {'name':'Tom','age':20,'gender':'男'}
#字典序列[key] = 值
#id的值是110
dict['id'] = 110
print(dict)
dict['name'] = 'ROSE'
print(dict)
删
dict = {'name':'Tom','age':20,'gender':'男'}
#del 删除字典或指定的键值对
#del(dict)#删除字典
del dict['name']#删除键值对，如果删除的键值对不存在则报错
print(dict)
#clear()#清空字典
dict.clear()
print(dict)
改
1.字典序列[key] = 值
dict = {'name':'Tom','age':20,'gender':'男'}
dict['name'] = 'Lily'
print(dict)
#不存在的就添加。
dict['id']=110
print(dict)
查找
1.key值查找:如果当前查找的key存在，则返回对应的值，否则则报错
2.函数
1.get()
语法：字典序列.get(key,默认值)
如果当前查找的key不存在则返回第二个参数（默认值),默认值默认为None
2.keys():查找字典中所有的key,返回可迭代对象。
3.values():查找字典中所有的value，返回可迭代对象
4.items():查找字典中所有的键值对，返回可迭代对象，元组数据1是字典的key，元组数据2是字典的value
dict = {'name':'Tom','age':20,'gender':'男'}
#1.key值查找
#如果当前查找的key存在，则返回对应的值，否则则报错
print(dict['name'])#Tom
#print(dict['names'])#报错
#函数
#1 .get()
print(dict.get('name'))#Tom
print(dict.get('names'))#None
print(dict.get('names',111))#111
#2.keys()#查找字典中所有的key,返回可迭代对象。
#该函数产生的是一个可迭代对象，可以使用for迭代。
print(dict.keys())#dict_keys(['name', 'age', 'gender'])
#3.values():查找字典中所有的value，返回可迭代对象
print(dict.values())#dict_values(['Tom', 20, '男'])
#4. items():查找字典中所有的键值对，返回可迭代对象，元组数据1是字典的key，元组数据2是字典的value
print(dict.items())
#dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
字典的循环遍历
key()
dict = {'name':'Tom','age':20,'gender':'男'}
for key in dict.keys():
print(key)
value()
dict = {'name':'Tom','age':20,'gender':'男'}
for value in dict.values():
print(value)
遍历键值对
dict = {'name':'Tom','age':20,'gender':'男'}
for item in dict.items():
print(item)
dict = {'name':'Tom','age':20,'gender':'男'}
#xx.items():返回可迭代对象，内部是元组元组内有两个数据
#第一个是字典的key，第二个是字典的value
for key,value in dict.items():
print(key)
print(value)
print(f'{key}={value}')
集合
集合没有顺序，不支持下标，不允许重复出现
创建使用{}或set(),如果要创建空集合只能使用set(),因为{}用来创建空字典。
#创建有数据的集合
s1 = {10,20,30,40,50}
print(s1)
s2 = {10,30,20,40,30,20}
print(s2)#重复的只显示一次
s3 = set('abc')
print(s3)#{'b', 'c', 'a'}
#2.创建空集合
s4 = set()
print(s4)#set()
print(type(s4))#<class 'set'>
s5 = {}
print(type(s5))#<class 'dict'>
增
add()：追加的是的单个数据
update()：追加的数据是序列
s1 = {10,20}
#1.集合是可变类型
#add()
s1.add(100)
print(s1)
#集合有去重功能，如果追加的数据是集合已有数据，则什么事情都不做
s1.add(100)
print(s1)
#add只能增加单个数据
#s1.add([10,20,30])#报错
#update():增加的数据是序列
s1.update([10,20,30,40,50])
print(s1)#{100, 40, 10, 50, 20, 30}
#s1.update(100)#报错
删
remove()：删除集合中的指定数据，如果数据不存在则报错
discard():删除集合中的指定数据，如果数据不存在不会报错
pop():随机删除集合中的某个数据，并返回这个数据
s1 = {10,20,30,40,50}
#remove():删除指定数据，数据不存在报错
s1.remove(10)
print(s1)
#s1.remove(10)#报错
#discard():删除指定数据，如果数据不存在不报错
s1.discard(10)
print(s1)
#随机删除某个数据，并返回这个数据
print(s1.pop())
查
in:判断数据在集合序列
not in:判断数据不在集合序列
s1 = {10,20,30,40,50}
#in / not in 判断数据10是否存在
print(10 in s1)#True
print(10 not in s1)#False
公共操作
1.运算符
| 运算符 | 描述 | ⽀持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
str1 = 'aa'
str2 = 'bb'
list1 = [1,2]
list2 = [10,20]
t1 = (1,2)
t2 = (10,20)
dict1 = {'name':'Python'}
dict2 = {'age':30}
#1.+：合并，支持字符串，列表，元组
print(str1 + str2)#aabb
print(list1+list2)#[1, 2, 10, 20]
print(t1+t2)#(1, 2, 10, 20)
#字典不能使用+号
#print(dict1+dict2)#报错
#2.*:复制，支持字符串，列表，元组
print(str1*2)#aaaa
print('-'*10)#----------
print(list1*2)#[1, 2, 1, 2]
print(t1*2)#(1, 2, 1, 2)
#字典不能使用*号
#print(dict1*2)#报错
#3.in/not in 判断元素是否存在，支持字符串，列表，元组，字典
#判断字符a是否存在
print('a' in str1)#True
print('a' not in str1)#False
print(1 in list1)#True
print(1 in t1)#true
print('name' in dict1)#True
print('name' in dict1.keys())#True
公共方法
| 函数 | 描述 |
|---|---|
| len() | 计算容器中元素个数 |
| del 或 del() | 删除 |
| max() | 返回容器中元素最⼤值 |
| min() | 返回容器中元素最⼩值 |
| range(start,end, step) | ⽣成从start到end的数字，步⻓为 step，供for循环使⽤ |
| enumerate() | 函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序列，同时列出数据和数据下标，⼀般⽤在 for 循环当中。 |
str1 = 'abcdefg'
list1 = [10,20,30,40,50]
t1 = (10,20,30,40,50)
s1 = {10,20,30,40,50}
dict1 = {'name':'Tom','age':18}
#len():计算容器中元素个数
print(len(str1))#7
print(len(list1))#5
print(len(t1))#5
print(len(s1))#5
print(len(dict1))#2
#del 或 del()删除
#del str1
#del list1
#del t1
#del(s1)
#del dict1['name']
#max():返回容器中元素最大值
print(max(str1))#g
print(max(list1))#50
print(max(t1))#50
print(max(s1))#50
#min():返回容器中元素最小值
print(min(str1))#a
print(min(list1))#10
print(min(t1))#10
print(min(s1))#10
#range(start,end,step):生产从start到end的数字包含start不包含end，步长为step,默认为1，供for使用
#如果不写开始，默认为0
#如果不写步长，默认为1
for i in range(1,10,2):
print(i)#1,3,5,7,9
for i in range(10):
print(i)#0,1,2,3,4,5,6,7,8,9
#enumerate():函数用于将一个可遍历的数据对象(如列表、元组或字符串）
#组合成为一个索引序列，同时列出数据和数据下标一般用在for循环中。
#语法：enumerate(可遍历对象,start=0):start参数用来设置遍历数据的下标，默认为0
list1 = ['a','b','c','d']
#enumerate()返回结果是元组，元组的第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
for i in enumerate(list1):
print(i,end=" ")#(0, 'a') (1, 'b') (2, 'c') (3, 'd')
for i in enumerate(list1,start=1):
print(i,end=" ")#(1, 'a') (2, 'b') (3, 'c') (4, 'd')
容器类型转换
| 函数 | 描述 |
|---|---|
| tuple() | 将某个序列转换成元组 |
| list() | 将某个序列转换成列表 |
| set() | 将某个序列转换成集合 |
list1 = [10,20,30,20,40,50]
s1 = {100,300,200,500}
t1 = ('a','b','c','d','e')
#tuple()：将某个序列转换成元组
print(tuple(list1))
print(tuple(s1))
#list()：将某个序列转换成列表
print(list(s1))
print(list(t1))
#set()：将某个序列转换成集合
print(set(list1))
print(set(t1))
推导式
目标：列表、字典、集合
推导式的作用：化简代码
列表推导式：用一个表达式创建一个有规律的列表或控制一个有规律列表
列表推导式又叫列表生成器
#需求：创建一个0-10的列表
'''
1.循环实现
2.列表推导式（化简代码：创建或控制有规律的列表）
'''
# while循环
list1 = []
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)
# for实现。。。
list2 = []
for i in range(10):
list2.append(i)
print(list2)
#列表推导式
#代码放到列表中。
#[列表中要返回的数据 for循环]
list3 = [i for i in range(10)]
print(list3)
#带if的列表推导式
#需求：创建0-10的偶数列表
#1.range()步长实现
list1 = [i for i in range(0,10,2)]
print(list1)
#1.2for循环加上if,创建有规律的列表
list2 = []
for i in range(10):
if i%2 == 0:
list2.append(i)
print(list2)
#2.if配合列表表达式
list3 = [i for i in range(10) if i%2 ==0]
print(list3)
#多个for循环实现列表推导式。
#需求：[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
#for循环
list1=[]
for i in range(1,3):
for j in range(3):
#列表里面追加元组，循环前尊卑一个空列表
list1.append((i,j))
print(list1)
#列表表达式
list2 = [(i,j) for i in range(1,3) for j in range(3)]
print(list2)
字典推导式的作用:快速合并列表为字典或提取字典中共的目标数据
#创建一个字典，字典key是1-5，value是这个数字的2次方
dict1 = {i:i**2 for i in range(1,5)}
print(dict1)
#将两个列表合并为一个字典
list1 = ['name','age','gender']
list2 = ['Tom',20,'man']
dict2 = {list1[i]:list2[i] for i in range(len(list1))}
print(dict2)
#总结
#1.如果两个列表数据个数相同，len统计任何一个列表的长度都可以
#2.如果两个列表数据个数不同，len统计数据多的列表数据个数会报错：len统计数据少的列表数据个数不会报错
#提取字典中的目标数据
counts = {'MBP':268,'HP':125,'DELL':201,'Lenovo':199,'acer':99}
#提取上述电脑数量大于等于200的字典数据
#获取所有键值对数据，判断v值大于等于200返回字典
count1 = {key:value for key,value in counts.items() if value >=200}
print(count1)
集合推导式
#创建一个集合，数据为下方列表的二次方
#list1 = [1,1,2]
list1 = [1,1,2]
set1 = {i ** 2 for i in list1}
print(set1)#集合有去重功能。
迭代器
迭代
我们知道 Python 中有一些对象可以通过 for 来循环遍历，比如：列表、元组、字符等，以字符串为例，如下所示：
for i in 'hello':
print(i)
"""
h
e
l
l
o
"""
这个遍历过程就是迭代。
可迭代对象
可迭代对象需具有 iter() 方法，它们均可使用 for 循环遍历，我们可以使用 isinstance() 方法来判断一个对象是否为可迭代对象，看下示例：
from collections import Iterable
print(isinstance('abc', Iterable))#True
print(isinstance({1,2,3},Iterable))#True
print(isinstance(1024,Iterable))#False
迭代器
迭代器需要具有 iter() 和 next() 两个方法，这两个方法共同组成了迭代器协议，通俗来讲迭代器就是一个可以记住遍历位置的对象，迭代器一定是可迭代的，反之不成立。
__iter__()：返回迭代器对象本身
__next__()：返回下一项数据
迭代器对象本质是一个数据流，它通过不断调用 next() 方法或被内置的 next() 方法调用返回下一项数据，当没有下一项数据时抛出 StopIteration 异常迭代结束。上面我们说的 for 循环语句的实现便是利用了迭代器。
我们试着自己来实现一个迭代器，如下所示：
class MyIterator:
def __init__(self):
self.s = '程序之间'
self.i = 0
def __iter__(self):
return self
def __next__(self):
if self.i < 4:
n = self.s[self.i]
self.i += 1
return n
else:
raise StopIteration
mi = iter(MyIterator())
for i in mi:
print(i)
"""
程
序
之
间
"""
生成器
生成器是用来创建迭代器的工具，其写法与标准函数类似，生成器的创建方式有很多种，比如：使用 yield 语句、生成器表达式（可以简单的理解为是将列表的 [] 换成了 ()，特点是更加简洁，但不够灵活）。看下示例：
yield 是一个关键字，作用和 return 差不多，差别在于 yield 返回的是一个生成器（在 Python 中，一边循环一边计算的机制，称为生成器），它的作用是：有利于减小服务器资源，在列表中所有数据存入内存，而生成器相当于一种方法而不是具体的信息，用多少取多少，占用内存小。
def reverse(data):
for i in range(len(data)-1, -1, -1):
yield data[i]
for char in reverse('Hello'):
print(char)
'''
o
l
l
e
H
'''
# 列表
lis = [x*x for x in range(5)]
print(lis)
# 生成器
gen = (x*x for x in range(5))
for g in gen:
print(g)
'''
[0, 1, 4, 9, 16]
0
1
4
9
16
'''
1616
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
