python基础(上)

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)) #  -- 整型
b = 1.1
print(type(b)) #  -- 浮点型
c = True
print(type(c)) #  -- 布尔型
d = '12345'
print(type(d)) #  -- 字符串
e = [10, 20, 30]
print(type(e)) #  -- 列表
f = (10, 20, 30)
print(type(f)) #  -- 元组
h = {10, 20, 30}
print(type(h)) #  -- 集合
g = {'name': 'TOM', 'age': 20}
print(type(g)) #  -- 字典

变量

变量：数据在内存中存储之后定义⼀个名称，这个名称就是变量。
定义变量：变量名 = 值

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))#

转换数据类型

转换数据类型的函数
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')))#
print(int('12',8))#10
#oct():将括号内的内容转换成八进制字符串
print(oct(22))#0o26
print(type(oct(22)))#
#hex()：将括号内的内容转换成十六进制字符串
print(hex(44))#0x2c
print(type(hex(44)))#
#float()将括号内的对象转换为一个浮点数
print(float(1))#1.0
print(type(float(1)))#
#str()将括号内的对象转换成一个字符串
print(str(1))#1
print(type(str(1)))#
#char():将括号内的整数转换为一个unicode字符
print(chr(65))#A
print(type(chr(65)))#
#ord():将括号内的字符转换为一个整数
print(ord('A'))#65
print(type(ord('A')))#
#tuple():将括号内的序列转换成一个元组
print(tuple([10,20,30]))#(10, 20, 30)
print(type(tuple([10,20,30])))#
#list():将括号内的序列转换成一个列表
print(list([1,2,3]))#[1, 2, 3]
print(type(list([1,2,3])))#
#complex(real[,imag]):创建一个复数real为实部,imag为虚部
print(complex(1,2))
print(type(complex(1,2)))
#repr():将对象转换成表达式字符串
print(repr('aaa'))#'aaa'
print(type(repr('aaa')))#
#eval():用来计算在字符串中的有效python表达式,并返回对应的类型
#eval()就是把字符串里面的数据转换成他本来的数据类型
str2 = '1'
str3 = '1.1'
str4 = '(1000,2000,3000)'
str5 = '[1000,2000,3000]'
print(type(eval(str2)))#
print(type(eval(str3)))#
print(type(eval(str4)))#
print(type(eval(str5)))#

'''
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))#

#空字典
dict2={}
print(type(dict2))#
dict3 = dict()
print(type(dict3))#

增
写法：字典序列[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))#
s5 = {}
print(type(s5))#

增
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
'''