03 运算符＋流程控制 + 数据类型详解

一、用户交互

用户交互：输入 输出

1.1 输入

input() 、input(字符串的提示)
当程序执行到这里，就会暂停，等待我们输入数据给电脑；会有一个结果，打印出来，用变量接受，因为输入数据后面需要用到，且得到的结果永远是字符串类型

1.2 输出

计算机将信息给你 —> 打印 —> print() 打印出来

• print(值, 值, 值)
• print(end = '\n') end以什么结尾，默认是换行
• print(值, 值, 值, sep = '') sep=‘’ 当打印多个时，以什么作为间隔，默认是空格

print(1,end = '我是哒哒')
print(666)

#结果：1我是哒哒666

格式化输出：

1. why?
   我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容

2. what / when ?
   把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。即需要输出的字符串中包含了变量时使用。

3. how?
   ① f'字符{变量名}' 变量的数据不限 （⭐推荐）

   a = 18
   b = [1,2,3]
   print(f'我的年龄是{a},{b}')
   
   # 结果：我的年龄是18,[1,2,3]
   

   ② format()方法

   print('我的年龄是{},{}'.format(a,b))
   print('我的年龄是{1},{0}'.format(a,b))
   
   结果：
   # 我的年龄是18[1,2,3]
   # 我的年龄是[1,2,3]18
   

   ③ %

   print('我的名字是%s，年龄是%s,'%('哒哒','18'))
   
   # 结果：我的名字是哒哒，年龄是18
   

二、运算符

算术运算符	描述	示例（x=9,y=2）
+	加，两个对象相加	x+y得11
-	减，两个对象相减	y-x得-7
*	乘，两个对象相乘	x*y得18
/	除，相除后得到的返回值会保留整数与小数部分	x/y得4.5
//	取整除，相除后得到的返回值只保留整数部分	x//y得4
%	取余，相除后只返回余数	x%y得1
**	幂，取一个数的n次方	x**y得81

比较运算符	说明（结果都是True或False）
>	大于，如果>前面的值大于后面的值，则返回 True，否则返回 False
<	小于，如果<前面的值小于后面的值，则返回 True，否则返回 False
==	等于，如果==两边的值相等，则返回 True，否则返回 False
>=	大于等于（等价于数学中的 ≥），如果>=前面的值大于或者等于后面的值，则返回 True，否则返回 False
<=	小于等于（等价于数学中的 ≤），如果<=前面的值小于或者等于后面的值，则返回 True，否则返回 False
!=	不等于（等价于数学中的 ≠），如果!=两边的值不相等，则返回 True，否则返回 False
is	判断两个变量所引用的对象是否相同，如果相同则返回 True，否则返回 False
is not	判断两个变量所引用的对象是否不相同，如果不相同则返回 True，否则返回 False

赋值运算符	描述	示例
=	简单赋值运算	x = 10
+=	加法赋值运算	x += 1 等同于x=x+1
-=	减法赋值运算	x -= 1 等同于x=x-1
*=	乘法赋值运算	同上
/=	除法赋值运算	同上
//=	取整除赋值运算	同上
%=	取余赋值运算	同上
**=	幂赋值运算	同上

其他赋值	描述	示例	原方案	结果
链式赋值	把同一个值同时赋值给多个变量名	x=y=z=10;	z=10; y=z; x=y;	print(x,y,z); # (10, 10, 10)
交叉赋值	将m与n的值交换过来	m=10; n=20; m,n=n,m;	temp=m; m=n; n=temp;	print(m,n); # (20, 10)
解压赋值	列表中的多个值取出来 依次赋值给多个变量名 （等号两边个数必须相同）	a,b,c,d,e=nums 【若只想取头尾的几个值，可以用 *_ 匹配】 a,b, * _=nums; print(a,b); # (11, 22)	nums=[11,22,33,44,55]; a=nums[0]; b=nums[1]; c=nums[2]; d=nums[3]; e=nums[4];	print(a,b,c,d,e) # (11, 22, 33, 44, 55)

逻辑运算符	含义	基本格式	说明
and	逻辑与运算，等价于数学中的“且”	a and b	当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假
or	逻辑或运算，等价于数学中的“或”	a or b	当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真
not	逻辑非运算，等价于数学中的“非”	not a	如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反

False：0 ，空字符串，空列表，空字典，空元组，空集合，None
本质：若左边 错误，则直接输出 左边 值；若左边 正确，则直接输出 右边 值。

print(100 and 200)        #True
print(45 and 0)           #0
print("" or "我是哒哒")    #我是哒哒
print(18.8 or "我是哒哒")  #18.5

成员运算符	描述（字符串，列表，元祖，字典，集合都支持）	示例
in	某一个对象包含于另外一个对象则返回True	a = ‘hello’ in ‘hello world’ # True
not in	某一个对象没有包含于另外一个对象则返回True	a = ‘hello’ not in ‘hello world’ #False

⚠️ 字典 根据键得到的值 。 print(‘a’ in {‘a’ : 123}) 结果为True print(‘123’ in {‘a’ : 123}) 结果为False

三、流程控制

python 程序可分为 三大结构：顺序结构、选择（分支）结构、循环结构

• 顺序结构 程序按照从头到尾的顺序依次执行每一条

• 选择（分支）结构 根据条件判断的真假去执行不同分支对应的子代码

• 循环结构 重复执行某段代码块

3.1 分支（选择）结构

3.1.1 三种形式

# 1. if 语句
if 表达式：
	代码块
    
# 2. if else 语句
if 表达式：
	代码块1
else：
    代码块2
	
# 3. if elif else 语句
if 表达式1：
	代码块1
elif 表达式2：
	代码块2
elif 表达式3：
    代码块3
else：
    代码块n

在 if 判断中所有的数据类型也都会自动转换成布尔类型，None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为 False,其余均为 True。

三目运算：条件 ? 条件真结果 : 条件假结果; 条件为真时的结果 if 判段的条件 else 条件为假时的结果

#三目运算符的嵌套
a if a>b else c if c>d else d
应该理解为
a if a>b else ( c if c>d else d )

3.1.2 if语句嵌套

# 在最简单的 if 语句中嵌套 if else 语句
if 表达式1：
    if 表示式2：
        代码块1
    else：
        代码块2
        
# 在 if else 语句中嵌套 if else 语句
if 表示式 1：
    if 表达式2：
        代码块1
    else：
        代码块2
else：
    if 表达式3：
        代码块3
    else：
        代码块4

3.1.3 pass语句

pass语句作用：占位，跳过
在实际开发中，有时候我们会先搭建起程序的整体逻辑结构，但是暂时不去实现某些细节。有时候程序需要占一个位置，或者放一条语句，但又不希望这条语句做任何事情，此时就可以通过 pass 语句来实现。pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做。

3.1.4 assert断言函数

assert语句，又称断言语句，可以看做是功能缩小版的 if 语句，它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行；值为假，Python 解释器会报 AssertionError 错误。

# assert 条件,'报错的提示'
if 表达式==True:
    程序继续执行
else:
    程序报 AssertionError 错误

条件为真 不做任何事情，条件为假 就报错。

assert 0; #不能为0，通过命令可关闭报错

📌assert 的检查是可以被关闭的，比如在命令行模式下运行 Python 程序时，加入 -O 选项就可以使程序中的 assert 失效。一旦 assert 失效，其包含的语句也就不会被执行。

3.2 循环结构

python中有 while 与 for 两种循环机制

for循环能做的事情，while循环都能做；while循环能做的事情，for不一定能做。所以，for循环是while循环的一种优化，如果python只能保留一种应保留 while

3.2.1 while 条件循环

什么时候结束重复循环？ 条件不成立时，即条件能发生变化（用变量来表示）

while 条件表达式：
    代码块(循环体)
    
while a<10:     #控制重复次数
    print(a)    #重复做的事情里 肯定要包含让你的次数发生变化的代码
    a+=1

3.2.2 for 迭代循环

常用于遍历字符串、列表、元组、字典、集合等序列类型，依次获取序列中的各个元素 数据

for 变量名 in 可迭代对象: # 可迭代对象可以是 str\list\dict\tuple\range()，
    代码一
    代码二
    ...
#例1
for item in ['a','b','c']:
    print(item)
# 运行结果
a
b
c
# 参照例1来介绍for循环的运行步骤
# 步骤1：从列表['a','b','c']中读出第一个值赋值给item（item=‘a’），然后执行循环体代码
# 步骤2：从列表['a','b','c']中读出第二个值赋值给item（item=‘b’），然后执行循环体代码
# 步骤3: 重复以上过程直到列表中的值读尽

3.2.3 循环结构中 强制结束循环

1）break 语句：终止，可以立即终止当前循环的执行，跳出当前所在的循环结构 退出

username = "jason"
password = "123"
# 记录错误验证的次数
count = 0
while count < 3:
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        print("登陆成功")
        break # 用于结束本层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

​ 循环嵌套+break
​ 如果循环嵌套了很多层，要想退出每一层循环则需要在每一层循环都有一个break，即一个关键词break对应一个循环

username = "jason"
password = "123"
count = 0
while count < 3:  # 第一层循环
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        print("登陆成功")
        while True:  # 第二层循环
            cmd = input('>>: ')
            if cmd == 'quit':
                break  # 用于结束本层循环，即第二层循环
            print('run <%s>' % cmd)
        break  # 用于结束本层循环，即第一层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

username = "jason"
password = "123"
count = 0

tag = True
while tag: 
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        print("登陆成功")
        while tag:  
            cmd = input('>>: ')
            if cmd == 'quit':
                tag = False  # tag变为False， 所有while循环的条件都变为False 
                break
            print('run <%s>' % cmd)
        break  # 用于结束本层循环，即第一层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

2）continue 语句：中断，可以跳过执行本次循环体中剩余的代码，转而执行下一次的循环

# 打印1到10之间，除7以外的所有数字
number=11
while number>1:
    number -= 1
    if number==7:
        continue 
        # 结束本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环
    print(number)

3）else
当 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束。若执行过程中被break，就不会执行else的语句。

count = 0
while count <= 5 :
    count += 1
    print("Loop",count)
else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦   #没有被break打断，所以执行了该行代码
-----out of while loop ------

# 如果执行过程中被break，就不会执行else的语句
count = 0
while count <= 5 :
    count += 1
    if count == 3:
        break
    print("Loop",count)
else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
-----out of while loop ------ #由于循环被break打断了，所以不执行else后的输出语句

3.2.4 循环嵌套

嵌套循环执行的总次数 = 外循环执行次数 * 内循环执行次数

# if 语句和循环（while、for）结构之间，也可以相互嵌套
i = 0
if i<10:
    for j in range(5):
        print("i=",i," j=",j) 

# if、while、for 之间支持多层（ ≥3 ）嵌套
if ...:
    while ...:
        for ...:
            if ...:
                ...

使用频率：int、float > list > dict > tuple 集合用的很少，除非特殊场景，集合主要用于求交集，并集，差集

四、整数类型（int）详解

4.1 数字相关的类型

十进制 二进制 八进制 十六进制

a = 123
print(bin(a))    #10进制转换为2进制
print(oct(a))    #10进制转换为8进制
print(hex(a))    #10进制转换为16进制

'''
结果：
0b1111011
0o173
0x7b
'''

# 进制转换
int()    转成10进制的数字
float()  转成小数

a = 123_456_789   # _来分割，每隔三个数字分隔一次，看起来更美观
pint(a)           # 结果为：123456789

五、字符串类型（string）详解

5.1 python支持的转义字符

转义字符	说明
\n	换行符，将光标位置移到下一行开头
\r	回车符，将光标位置移到本行开头
\t	水平制表符，也即 Tab 键，一般相当于四个空格
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效
\b	退格（Backspace），将光标位置移到前一列
\\	反斜线
\’	单引号
\"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写

5.2 索引与切片⭐

• 从左到右，以 0 开始，从右往左，以 -1 开始。
• 索引：序列中，每个元素都有属于自己的编号（索引） 序列名称[索引]
• 切片：访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列 序列名称[起始位 : 结束位 : 步长] 起始位：默认从 0 开始，结束位：不包括自己。
• ① [数字n] 第n个索引； ② [数字a : 数字b] 第a个到第b-1个的索引； ③ [数字a : 数字b : 数字k] 第a个到第b-1个的索引，中间步长为k个

a = '我是哒哒'
print(a)
print(a[2])          # 取第2个索引的字符
print(a[0:2])        # 取出从第0开始到第2-1个索引的字符
print(a[::-1])       # 倒序

📌 字符串里面的字符只能看，不能修改
str() 转换成为字符串； in 判断是否包含； + 拼接； * 重复多次

5.3 列表常用方法 ⭐

# 1）strip()  取出字符串左右两边指定的字符，默认是空格。常用于 接受用户的输入
#	lstrip()  去除左边的      rstrip()  去除右边的
    a = '         我      '
    b = '***我******'
    c = '***我'
    print(a.strip())        # 结果：我
    print(b.strip('*'))     # 结果：我
    print(c.strip('*'))     # 结果：我
# 2）len()    得到字符串中字符的个数。常用于 密码的长度
# 3）in 和 not in     左边的字符是否在右边的字符串当中
# 4）split()  以什么符号进行分隔，默认以空格分隔，得到一个列表
# 5）字符串可以for的遍历循环
# 6）lower()  将字符串全部转成小写   upper()  将字符串全部转成大写   可用于验证码
# 7）endswith()  判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False   
# 	startswith() 判断.......................开头，结果为布尔值True或False
	a = '1.jpg'
	print(a.endswith('jpg'))     # 结果：True    
# 8）join()   按照指定的字符拼接起来形成一个新的字符串
	a = '12345'
	print('+'.join(a))          # 结果：1+2+3+4+5
# 9）replace()  以什么字符来替换什么字符
# 10）isdigit() 判断是否为纯数字  
# 11）split() 从左到右的顺序对字符串进行切分，可以指定切割次数
# 	 rsplit() 从右往左切割，可以指定切割次数
    str5='C:/a/b/c/d.txt'
    print(str5.split('/',1))        # 结果： ['C:', 'a/b/c/d.txt']  
    str5='a|b|c'
    print(str5.rsplit('|',1))       # 结果： ['a|b', 'c']

5.4 其他操作（了解）

# 1.find,rfind,index,rindex,count
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
msg='tony say hello'
print(msg.find('o',1,3))  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
#1  

# 1.2 index:同find,但在找不到时会报错
print(msg.index('e',2,4)) # 报错ValueError

# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
msg = "hello everyone"
print(msg.count('e'))  # 统计字符串e出现的次数
# 4
print(msg.count('e',1,6))  # 字符串e在索引1~5范围内出现的次数
# 1

# 2.center,ljust,rjust,zfill
name='tony'
print(name.center(30,'-'))  # 总宽度为30，字符串居中显示，不够用-填充
# -------------tony-------------
print(name.ljust(30,'*'))  # 总宽度为30，字符串左对齐显示，不够用*填充
# tony**************************
print(name.rjust(30,'*'))  # 总宽度为30，字符串右对齐显示，不够用*填充
# **************************tony
print(name.zfill(50))  # 总宽度为50，字符串右对齐显示，不够用0填充
# 0000000000000000000000000000000000000000000000tony

# 3.expandtabs
name = 'tony\thello'  # \t表示制表符(tab键)
print(name)
# tony    hello
print(name.expandtabs(1))  # 修改\t制表符代表的空格数
# tony hello

# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
message = 'hello everyone nice to meet you!'
print(message.capitalize())
# Hello everyone nice to meet you! 

# 4.2 swapcase：大小写翻转
message1 = 'Hi girl, I want make friends with you!'
print(message1.swapcase()) 
# hI GIRL, i WANT MAKE FRIENDS WITH YOU! 

#4.3 title：每个单词的首字母大写
msg = 'dear my friend i miss you very much'
print(msg.title())
# Dear My Friend I Miss You Very Much 

# 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit())
# True
print(num2.isdigit())
# True
print(num3.isdigit())
# False
print(num4.isdigit()) 
# False

#isdecimal:uncicode(bytes类型无isdecimal方法)
print(num2.isdecimal()) 
# True
print(num3.isdecimal()) 
# False
print(num4.isdecimal()) 
# False

#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
print(num2.isnumeric()) 
# True
print(num3.isnumeric()) 
# True
print(num4.isnumeric()) 
# True

# 三者不能判断浮点数
num5 = '4.3'
print(num5.isdigit())
# False
print(num5.isdecimal())
# False
print(num5.isnumeric())
# False

'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''

# 6.is其他
name = 'tony123'
print(name.isalnum()) 	# 字符串中既可以包含数字也可以包含字母
# True
print(name.isalpha()) 	# 字符串中只包含字母
# False
print(name.isidentifier()) # 检查一个字符串是否是Python有效的标识符
# True
print(name.islower())  # 字符串是否是纯小写
# True
print(name.isupper())  # 字符串是否是纯大写
# False
print(name.isspace())  # 字符串是否全是空格
# False
print(name.istitle())  # 字符串中的单词首字母是否都是大写
# False

六、列表（List）详解 ⭐⭐

可用于 存储多个数据

6.1 创建列表

1）定义列表 ： [] 用 , 号隔开多个元素，这些元素可以是任意的类型 数字类型无法转成列表

#1.字符串 转换成列表
list1 = list("hello")
print(list1)              #结果1：['h', 'e', 'l', 'l', 'o']
#2.元组 转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)              #结果2：['Python', 'Java', 'C++', 'JavaScript']
#3.字典 转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)              #结果3：['a', 'b', 'c']
#4.区间 转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)              #结果4：[1, 2, 3, 4, 5]
#5.创建空列表
print(list())             #结果5：[]

6.2 访问列表元素

• 索引访问列表元素的格式：列表[索引] listname[i]
• 切片访问列表元素的格式：列表[开始索引 : 结束索引 : 步长] listname[start : end : step]

6.3 列表的常用方法

6.3.1 按索引存取值(正向存取+反向存取)：既可存也可取

# 1.1 正向取(从左往右)
my_friends=['tony','jason','tom',4,5]
print(my_friends[0])  
# tony

# 1.2 反向取(负号表示从右往左)
print(my_friends[-1])  
# 5

# 1.3 对于list来说，既可按照索引取值，又可按照索引修改指定位置的值，但若索引不存在则报错
my_friends = ['tony','jack','jason',4,5]
my_friends[1] = 'martthow'
print(my_friends)
# ['tony', 'martthow', 'jason', 4, 5]

6.3.2 切片(顾头不顾尾，步长)

my_friends=['tony','jason','tom',4,5]
# 2.1 顾头不顾尾：取出索引为0到3的元素
print(my_friends[0:4]) 
# ['tony', 'jason', 'tom', 4]

# 2.2 步长：0:4:2,第三个参数2代表步长，从0开始，每次累加一个2即可，故取出索引0、2的元素
print(my_friends[0:4:2])  
# ['tony', 'tom']

6.3.3 长度 len()

my_friends=['tony','jason','tom',4,5]
print(len(my_friends))
# 5

6.3.4 成员运算in和not in

my_friends=['tony','jason','tom',4,5]
print('tony' in my_friends)
# True
print('xxx' not in my_friends)
# True

6.3.5 添加

# 5.1 append()列表尾部追加元素
l1 = ['a','b','c']
l1.append('d')
print(l1)
# ['a', 'b', 'c', 'd']

# 5.2 extend()一次性在列表尾部添加多个元素
l1.extend(['a','b','c'])
print(l1)
# ['a', 'b', 'c', 'd', 'a', 'b', 'c']

# 5.3 insert()在指定位置插入元素
l1.insert(0,"first")  # 0表示按索引位置插值
print(l1)
# ['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

6.3.6 删除

# 6.1 del
l = [11,22,33,44]
del l[2]  # 删除索引为2的元素
print(l)
# [11,22,44]

# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
l = [11,22,33,22,44]
res=l.pop()
print(res)
# 44
res=l.pop(1)
print(res)
# 22

# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
l = [11,22,33,22,44]
res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
print(res)
# None

6.3.7 reverse()颠倒列表内元素顺序

l = [11,22,33,44]
l.reverse() 
print(l)
# [44,33,22,11]

6.3.8 sort()给列表内所有元素排序

# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
l = [11,22,3,42,7,55]
l.sort()
print(l) 
#[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
print(l) 
# [55, 42, 22, 11, 7, 3]

# 8.2 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
l1=[1,2,3]
l2=[2,]
print(l2 > l1) 
# True

# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1='abc'
s2='az'
print(s2 > s1) # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
# True
# 所以我们也可以对下面这个列表排序
l = ['A','z','adjk','hello','hea']
l.sort()
print(l)
# ['A', 'adjk', 'hea', 'hello','z']

6.3.9 循环

# 循环遍历my_friends列表里面的值
my_friends=['tony','jason','tom',4,5]
for line in my_friends:
    print(line) 

遍历：for x in 列表 将字符串中的每一个字符（列表中的每一个元素，字典中的每一个键，元组中的每一个元组）依次赋值给前面的变量，执行for里面的代码

📌 列表 索引 切片的取值，列表不能超出索引，否则报错
列表是可以修改的，列表[索引] = 新的值

七、字典（dict）详解

保存多个数据。 和列表的区别：列表是没有描述性质的
字典：键值对 (key-value) 的形式 键对于值有描述性的功能，一种无序的、可变的序列

{key : value, key : value} 键：只能是int, float, str, tuple，常用str；值：可以是任意的类型

主要特征	解释
通过键来读取元素 而不是通过索引	字典类型有时也称为关联数组或者散列表（hash）。它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取
字典是任意数据类型的 无序集合	和列表、元组不同，通常将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的
字典是可变的，并且可以任意嵌套	字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典
字典中的键必须 唯一	字典中，不支持同一个键出现多次，否则只会保留最后一个键值对
字典中的键必须 不可变	字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表

7.1 创建字典

7.1.1 使用 {} 创建字典

#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}    # 空字典，对应False
print(dict2)

7.1.2 通过 fromkeys() 方法创建字典

# list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None
# dictname = dict.fromkeys(list列表/字符串，value=None)  

knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 60)
print(scores)
# {'语文': 60, '数学': 60, '英语': 60}

7.1.3 通过 dict() 映射函数创建字典

a = dict(str1=value1, str2=value2, str3=value3)
# str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号

#方式1：列表套元组
demo = [('two',2), ('one',1), ('three',3)]
#方式2：列表套列表
demo = [['two',2], ['one',1], ['three',3]]
#方式3：元组套元组
demo = (('two',2), ('one',1), ('three',3))
#方式4：元组套列表
demo = (['two',2], ['one',1], ['three',3])
a = dict(demo)
# 向dict()函数传入列表或元组，而它们中的元素又各自是包含2个元素的列表或元组，其中第一个元素作为键，第二个作为值。
# {'two': 2], 'one': 1, 'three': 3}


keys = ['one', 'two', 'three'] #还可以是字符串或元组
values = [1, 2, 3] #还可以是字符串或元组
a = dict( zip(keys, values) )
# 通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典
# {'two': 2], 'one': 1, 'three': 3}

7.2 访问字典

1）格式：字典名[键名]   dictname[key]      
# 如果没有这个键，就会报错
	
2）格式：字典名.get(键名, 默认值)    dictname.get(key[,default])
# 使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get()方法不会抛出异常
# default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数

7.3 字典的常用方法

7.3.1 按key存取值（可存可取）

# 1.1 取
dic = {
	'name': 'xxx',
	'age': 18,
	'hobbies': ['play game', 'basketball']
}
print(dic['name'])
# 'xxx'
print(dic['hobbies'][1])
# 'basketball'

# 1.2 对于赋值操作，如果key原先 不存在 于字典，则会 新增key:value
dic['gender'] = 'male'  
print(dic)
# {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}

# 1.3 对于赋值操作，如果key原先 存在 于字典，则会 修改对应value的值
dic['name'] = 'tony'
print(dic)
# {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}

7.3.2 长度len()、成员运算in和not in、删除

# 2、长度len
dic = {
	'name': 'xxx',
	'age': 18,
	'hobbies': ['play game', 'basketball']
}
print(len(dic))
# 3

# 3、成员运算in和not in
print('name' in dic)  # 判断某个值是否是字典的key
# True

# 4、删除           也可用del删除，但不推荐
dic.pop('name')  # 通过指定字典的key来删除字典的键值对
print(dic)
# {'age': 18, 'hobbies': ['play game', 'basketball']}

7.3.3 键keys()，值values()，键值对items()

一般结合循环使用

dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}

# 5.1 获取字典所有的key
print(dic.keys())  
# dict_keys(['name', 'age', 'hobbies'])

# 5.2 获取字典所有的value
print(dic.values())
# dict_values(['xxx', 18, ['play game', 'basketball']])

# 5.3 获取字典所有的键值对
print(dic.items())
# dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

7.3.4 循环

# 6.1 默认遍历的是字典的key
for key in dic:
	print(key)

# 6.2 只遍历key，结果与6.1同
for key in dic.keys():
	print(key)

# 6.3 只遍历value
for key in dic.values():
	print(key)

# 6.4 遍历key与value，形成元组(key,value)
for key in dic.items():
	print(key)
# x得到键，y得到值
for x,y in dic.items():
	print(x,y)

7.3.5 重要的函数（总结）

# 7.1 get()			取值
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
print(dic.get('k1'))
# 'jason'  # key存在，则获取key对应的value值
res=dic.get('xxx') # key不存在，不会报错而是默认返回None
print(res)
# None  
res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
print(res)
# 666 
# ps:字典取值建议使用get方法

# 7.2 pop()			删除指定键值对
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
print(dic)
# {'k1': 'jason', 'kk2': 'JY'}
print(v)
# 'Tony'

# 7.3 popitem()		随机删除一组
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
item = dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回
print(dic)
# {'k3': 'JY', 'k2': 'Tony'}
print(item)
# ('k1', 'jason')

# 7.4 update()		新增/修改
# 用新字典更新旧字典，有则修改，无则添加
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
dic.update({'k1':'JN','k4':'xxx'})
print(dic)
# {'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

# 7.5 fromkeys()
dic = dict.fromkeys(['k1','k2','k3'],[])
print(dic)
# {'k1': [], 'k2': [], 'k3': []}

# 7.6 setdefault()
# 1) key不存在 则新增键值对，并将新增的value返回
dic={'k1':111,'k2':222}
res=dic.setdefault('k3',333)
print(res)
# 333
print(dic) # 字典中新增了键值对
# {'k1': 111, 'k3': 333, 'k2': 222}

# 2) key存在则 不做任何修改，并返回已存在key对应的value值
dic={'k1':111,'k2':222}
res=dic.setdefault('k1',666)
print(res)
# 111
print(dic) # 字典不变
# {'k1': 111, 'k2': 222}

八、元组（tuple）详解

元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列

元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容

从形式上看，元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔 (元素 , 元素 , ...)

8.1 创建元组

1）使用 ( ) 直接创建 ： 元组名(元素, 元素, …)

⚠️ 如果只有一个元素，也必须加一个 , 否则就不是元组类型，元素是什么类型就是什么类型

2）使用tuple()函数创建元组：tuple(data)

#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)
#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)
#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)
#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)
#创建空元组
print(tuple())

8.2 修改元组

元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组

可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素

tup1 = (100, 0.5, -36, 73)
tup2 = ( -54.6, 99)
print(tup1+tup2)
print(tup1)
print(tup2)
# 使用+拼接元组以后，tup1 和 tup2 的内容没法发生改变，这说明生成的是一个新的元组

8.3 元组和列表的区别

1）最大的区别：列表中的元素可以进行任意修改；元组中的元素无法修改，除非将元组整体替换掉。tuple 元组是一个只读版本的 list 列表。

2）元组的性能速度要优于列表

# 对于列表和元组来说，虽然它们都是空的，但元组却比列表少占用 16 个字节
listdemo = []
print(listdemo.__sizeof__())
# 40
tupleDemo = ()
print(tupleDemo.__sizeof__())
# 24

由于列表是动态的，它需要存储指针来指向对应的元素（占用 8 个字节）。另外，由于列表中元素可变，所以需要额外存储已经分配的长度大小（占用 8 个字节）。但是对于元组，情况就不同了，元组长度大小固定，且存储元素不可变，所以存储空间也是固定的。

通过对比列表和元组存储方式的差异，可得出结论：元组要比列表更加轻量级，所以从总体上来说，元组的性能速度要优于列表

3）元组的 不可替代性 体现在以下这些场景中：

1. 元组作为很多内置函数和序列类型方法的返回值存在，即 在使用某些函数或者方法时，它的返回值会元组类型，因此你必须对元组进行处理
2. 元组比列表的访问和处理速度更快，因此，当需要对指定元素进行访问，且不涉及修改元素的操作时，建议使用元组
3. 元组可以在映射（和集合的成员）中当做“键”使用，而列表不行

九、集合（set）详解

用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。集合主要用于：去重、关系运算

从形式上看，集合会将所有元素放在一对大括号 {} 中，相邻元素之间用 , 分隔 {元素 , 元素 , ...}

从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误

定义：在{}内用逗号分隔开多个元素，集合具备以下
⭐三个特点：
	1. 每个元素必须是不可变类型
	2. 集合内没有重复的元素      去重处理
	3. 集合内元素无序

9.1 创建set集合

1）使用 {} 创建：集合名 = {元素, 元素, 元素, ...} setname = {element1,element2,…,elementn}

2）set()函数创建集合：集合名 = set(字符串、列表、元组、range 对象等数据) setname = set(iteration)

9.2 访问set集合元素

由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来

a = {1,'c',1,(1,2,3),'c'}
for ele in a:
    print(ele,end=' ')

9.3 集合的常用方法

9.3.1 关系运算

合集/并集( | )、交集( & )、差集( - )、对称差集( ^ )、值是否相等( ==)、父集、子集

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
print(friends1 | friends2)
# {'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友
print(friends1 & friends2)
# {'jason', 'egon'}

# 3.差集(-)：
print(friends1 - friends2) # 求用户1独有的好友
# {'kevin', 'zero'}
print(friends2 - friends1) # 求用户2独有的好友
# {'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
# {'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
print(friends1 == friends2)
# False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
print({1,2,3} > {1,2})
# True
print({1,2,3} >= {1,2})
# True
# 6.2 不存在包含关系，则返回False
print({1,2,3} > {1,3,4,5})
# False
print({1,2,3} >= {1,3,4,5})
# False

# 7.子集
print({1,2} < {1,2,3})
# True
print({1,2} <= {1,2,3})
# True

9.3.2 去重

集合去重的局限性：① 只能针对不可变类型； ② 集合本身是无序的，去重之后无法保留原来的顺序。

l=['a','b',1,'a','a']
s=set(l)
print(s) # 将列表转成了集合
# {'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
print(l_new)
# ['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
# [
#     {'age': 18, 'sex': 'male', 'name': 'lili'}, 
#     {'age': 73, 'sex': 'male', 'name': 'jack'}, 
#     {'age': 20, 'sex': 'female', 'name': 'tom'}
# ]

9.3.3 其他操作

# 1.长度
s={'a','b','c'}
print(len(s))
# 3

# 2.成员运算
print('c' in s)
# True

# 3.循环
for item in s:
	print(item)

十、可变类型与不可变类型

• 可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值 [列表，字典，集合]

• 不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值 [数字，字符串，元祖]

📌 扩展知识点：

• 只要内容更改，内存地址就更改，ID变化 int float str tuple
• 只要发生修改，内存地址就马上修改 ==> 不可变数据类型
• 发生了修改，内存地址不会发生变化 ==> 可变数据类型 list dist set
• 元组不能修改，指的是元组内部元素的内存地址不能修改。若元组的元素是列表/字典，列表/字典的修改不会更改内存地址。（不建议使用，装逼知识点😎）