Python基础语法学习记录

输出

将结果或内容呈现给用户

print("休对故人思故国，且将新火试新茶，诗酒趁年华")
# 输出不换行，并且可以指定以什么字符结尾
print("青山依旧在",end= ",")
print("几度夕阳红",end= "。")

2.数据类型

2.1 整型(int)

print(222)
print(2 ** 2)  # 2的2次方
print(10 / 2)

2.2 字符串(str)

# 单引号和双引号一样
print("Hello World")
print("上海市浦东新区")
print("我是'艾伦'")
# """表示多行字符串
print("""
人生到处何所似,
应是飞鸿踏雪泥。
"""
)

对于字符串：

• 拼接: +
• 乘：整型和字符串进行相乘，实现字符串重复出现N次并拼接

print(3 * "我想吃拉面")

2.3 布尔类型(bool)

bool类型种共有两个值：True/False

print(1 > 2)
print(False)
print(True)
print(1 == 1)

name = input("请输入你的用户名: ")
if name.lower() == "zed":
    print(name + "登录成功")
else:
    print("登录失败")

补充：

1 == ‘Alan’ # 可以比较

1 > ‘Alan’ # 不可以进行比较

2.4 数据类型转换

不同的数据类型有不同的功能，如果想要做转换，可遵循一个原则，想转换什么类型就让它包裹住

如：str(666)是将整型转化为字符串，int(“888”)是将字符串转为整型

类型转换

• 其他所有类型转为布尔类型时，除了空字符串、0以外其他都是True；
• 字符串转为整型时，只有是数字类型的字符串（“669”）才可转换为整型，其他都报错；
• 想要转换为哪种类型，就用这个类型的英文包裹一下就可以

str(…)

int(…)

bool(…)

3.变量

注意：

• 给变量赋值；
• 让age代指某个值；

name = "Zed"
age = 24
flag = 1 > 2
print(name)
print(age)
print(flag)

3.1 变量名的规范

三个规范：

• 变量名由字母、数字、下划线组成；
• 不能以数字开头；
• 不能用Python内置的关键字；

变量内存指向

情景一

name = "sushi"

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域。

情景二

name = "sushi"
name = "alex"

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域。然后又再内存中创建了一块域保存字符串”alex”，name变量名则指向”alex”所在的区域，不再指向”sushi”所在区域（无人指向的数据会被标记为垃圾，由解释器自动化回收）

情景三

name = "sushi"
new_name = name

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域。new_name变量名指向name变量，因为被指向的是变量名，所以自动会转指向到name变量代表的内存区域。

情景四

name = "sushi"
new_name = name
name = "alex"

在计算机的内存中创建一块区域保存字符串”sushi”，name变量名则指向这块区域(灰色线)， 然后new_name指向name所指向的内存区域，最后又创建了一块区域存放”alex”，让name变量指向”alex”所在区域.

情景五

num = 18
age = str(num)

在计算机的内存中创建一块区域保存整型18，name变量名则指向这块区域。通过类型转换依据整型18再在内存中创建一个字符串”18”, age变量指向保存这个字符串的内存区域。

4.注释

• 单行注释

# 声明一个name变量
name = 'Alan'

• 多行注释

"""
这是一个多行注释
这是一个多行注释
这是一个多行注释
这是一个多行注释
"""

5.输入

实现用户与程序之间的交互

# 接收用户输入的变量
name = input("请输入用户名: ")

特别注意:

用户输入的任何内容都是字符串；

6.条件语句

if 条件:
    ...
else:
    ...

6.1 基本条件语句

• 示例1

  username = "sushi"
  password = "666"
  if username == "sushi" and password == "666":
  	print("恭喜你，登录成功")
  else:
  	print("登录失败")
  

• 示例2

  username = "sushi"
  
  if username == "sushi" or username == "alex":
  	print("VIP大会员用户")
  else:
  	print("普通用户")
  

• 示例3

  number = 19
  if number%2 == 1:
  	print("number是奇数")
  else:
  	print("number是偶数")
  

  number = 19
  data = number%2 == 1
  if data:
  	print("number是奇数")
  else:
  	print("number是偶数")
  

• 示例4

  if 条件:
    成立
  

  print("开始")
  if 5 == 5:
    print("5等于5")
  print("结束")
  

6.2 多条件判断

if 条件A:
  A成立，执行此缩进中的所有代码
  ...
elif 条件B:
  B成立，执行此缩进中的所有代码
  ...
elif 条件C:
  C成立，执行此缩进中的所有代码
  ...
else:
  上述ABC都不成立。

6.3 条件嵌套

if 条件A:
    if 条件A1:
        ...
    else：
   	    ...
elif 条件B:
    ...

模拟10086客服

print("欢迎致电10086，我们提供了如下服务： 1.话费相关；2.业务办理；3.人工服务")

choice = input("请选择服务序号")

if choice == "1":
    print("话费相关业务")
    cost = input("查询话费请按1;交话费请按2")
    if cost == "1":
        print("查询话费余额为100")
    elif cost == "2":
        print("交互费")
    else:
        print("输入错误")
elif choice == "2":
    print("业务办理")
elif choice == "3":
    print("人工服务")
else:
    print("序号输入错误")

7. 循环语句

• while循环

while 条件:
	...
	...
	...

• for循环

7.1 循环语句基本使用

num = 1
while num < 4:
    print("2024发大财")
    num += 1

7.2 break 终止循环

break，用于while循环中终止循环；

7.3 continue结束本次循环

continue, 在循环中用于结束本次循环，开始下一次循环；

7.4 while else

当while后的条件不成立时，else中的代码就会执行

while 条件:
    代码
else:
    代码

num = 1
while num < 5:
    print("2024一夜暴富")
    num += 1
else:
    print("2024一定会发财")

8. 字符串格式化

8.1 %格式化

# 引入
name = "苏东坡"
age = 18
text = "我叫%s，今年%d岁" %(name,age)

message = "%(name)s你什么时候过来呀？%(user)s今天不在呀。" % {"name": "死鬼", "user": "李杰"}
print(message)

8.1.2 百分比特殊处理

text = "%s，这个片我已经下载了90%%了，居然特么的断网了" %"兄弟"
print(text)
# 输出：
兄弟，这个片我已经下载了90%了，居然特么的断网了

8.2 format格式化（推荐）

text1 = "我叫{0}, 今年{1}岁".format("Alan",19)
text2 = "我叫{0}, 今年{1}岁,真实姓名是{0}".format("Alan",19)
print(text1)
print(text2)
################################
text = "我叫{n1}，今年18岁".format(n1="Alan")
text = "我叫{n1}，今年{age}岁".format(n1="Alan",age=18)
text = "我叫{n1}，今年{age}岁，真是的姓名是{n1}。".format(n1="Alan",age=18)
################################
# 先定义格式化字符串，再调用format方法传递参数
text = "我叫{0}，今年{1}岁"
data1 = text.format("Alan",666)
data2 = text.format("alex",73)
address = "{0}市{1}区{2}街道"
print(address.format("上海","浦东新","溜溜"))

8.3 f格式化（Python3.6之后）

hobby1 = "打游戏"
hobby2 = "打球"
message = f"我喜欢{hobby1},还喜欢{hobby2}"
###
输出: 我喜欢打游戏,还喜欢打球  
###

9. 运算符

9.1 算数运算符

9.2 比较运算符

9.3 赋值运算

9.4 成员运算

9.5 逻辑运算

10. Python数据类型

常见数据类型：

• int，整数类型
• bool，布尔类型
• str，字符串；
• list，列表类型；
• tuple，元组类型；
• dict，字典类型；
• set，集合类型；
• float，浮点型；

10.1 整型

10.1 定义

number = 10
age = 99

10.2 独有功能

无

v1 = 5
print(bin(v1))  # 0b101
# 调用v1（int）的独有功能，获取v1的二进制有多少个位组成。
result1 = v1.bit_length()
print(result1)  # 3

v2 = 10
print(bin(10))  # 0b1010
# 调用v2（int）的独有功能，获取v2的二进制有多少个位组成。
result2 = v2.bit_length()
print(result2)  # 4

10.3 公共功能

加减乘除

v1 = 4
v2 = 8
v3 = v1 + v2

10.4 转换

在项目开发和面试题中经常会出现一些 “字符串” 和 布尔值 转换为 整型的情况。

# 布尔值转整型
n1 = int(True)  # True转换为整数 1
n2 = int(False) # False转换为整数 0

# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8)  # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16)  # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）

# 浮点型（小数）
v1 = int(8.7) # 8

所以，如果以后别人给你一个按 二进制、八进制、十进制、十六进制 规则存储的字符串时，可以轻松的通过int转换为十进制的整数。

10.5 其他

10.5.1 长整型

• Python3：整型（无限制）
• Python2：整型、长整形

在python2中跟整数相关的数据类型有两种：int(整型)、long（长整型），他们都是整数只不过能表示的值范围不同。

• int，可表示的范围：-9223372036854775808～9223372036854775807
• long，整数值超出int范围之后自动会转换为long类型（无限制）。

在python3中去除了long只剩下：int（整型），并且 int 长度不在限制。

10.5.2 地板除

• Py3：

  v1 = 9/2 
  print(v1) # 4.5
  

• py2:

  v1 = 9/2 
  print(v1) # 4
  

  from __future__ import division 
  
  v1 = 9/2 
  print(v1) # 4.5
  

10.2 布尔型

10.3 字符串

"xxxx".方法名(参数)

s = "xxx"
s.方法名(...)

10.3.1 判断字符串是否以XX为开头startswith

# 案例
s.startswith("北京市")

10.3.2 判断字符串是否以XX结尾endswith

s.endswith("大厦")

10.3.3 判断字符串是否是整数

message.isdecimal()

10.3.4 判断字符串是否为十进制数

v1 = "123"
print(v1.isdecimal()) # True

v2 = "①"
print(v2.isdecimal()) # False

v3 = "123"
print(v3.isdigit()) # True

v4 = "①"
print(v4.isdigit()) # True

10.3.5 去除字符串两边的空格、换行符、制表符，得到一个新字符串

msg = " H e ll o啊，树哥 "
data = msg.strip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥"

msg = " H e ll o啊，树哥 "
data = msg.lstrip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥 "

msg = " H e ll o啊，树哥 "
data = msg.lstrip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥 "

案例：

# 案例
code = input("请输入4位验证码：") #  FB88   fb88 
value = code.upper() #  FB88  
data = value.strip() # FB88

if data == "FB87":
	print('验证码正确')
else:
	print("验证码错误")
  
# 注意事项
"""
code的值"fb88 "
value的值"FB88 "
data的值"FB88"
"""

去除两边指定的内容：

msg = "哥H e ll o啊，树哥"
data = msg.strip("哥")
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树"

10.3.5 字符串变大写

msg = "my name is the flash"
data = msg.upper()
print(data) # MY NAME IS THE FLASH

10.3.6 字符串变小写

msg = "MY NAME IS THE FLASH"
data = msg.lower()
print(data) # my name is the flash

10.3.7 字符串的替换

data = "你是个好人，但是好人不合适我"
value = data.replace("好人","贱人")
print(data)  # "你是个好人，但是好人不合适我"
print(value) # "你是个贱人，但是贱人不合适我"

# 案例
video_file_name = "喜剧片.mp4"
new_file_name = video_file_name.replace("mp4","avi") # "喜剧片.avi"
final_file_name = new_file_name.replace("喜剧","科幻") # "科幻片.avi"
print(final_file_name)

10.3.8 字符串的切割

data = "Alan|root|alan@qq.com"
result = data.split('|') # ["Alan","root","alan@qq.com"]
result2 = data.split('|', 1) # 切一个，遇到第一个切
result3 = data.rsplit('@') #
print(data) # "Alan|root|alan@qq.com"
print(result) # 输出 ["Alan","root","alan@qq.com"] 根据特定字符切开之后保存在列表中，方便以后的操作

10.3.9 字符串的拼接

data_list = ["Alan", "", "a", "huge","man"]
new_str = " ".join(data_list) # Alan is a huge man
print(new_str)

10.3.10 格式化字符串

address = "{0}市{1}区{2}街道"
data = address.format("上海","浦东新", "潍坊")
print(data) #上海市浦东新区潍坊街道

10.3.11 字符串转为字节类型

data = "苏东坡"  # unicode，字符串类型

v1 = data.encode("utf-8")  # utf-8，字节类型
v2 = data.encode("gbk")  # gbk，字节类型

print(v1)  # b'\xe8\x8b\x8f\xe4\xb8\x9c\xe5\x9d\xa1'
print(v2)  # b'\xcb\xd5\xb6\xab\xc6\xc2'

s1 = v1.decode("utf-8") # 苏东坡
s2 = v2.decode("gbk") # 苏东坡
print(s1)
print(s2)

10.3.12 字符串内容居中、居左、居右显示

v1 = "王老汉"
# data = v1.center(21, "-")
# print(data) #---------王老汉---------

# data = v1.ljust(21, "-")
# print(data) # 王老汉------------------

# data = v1.rjust(21, "-")
# print(data) # ------------------王老汉

10.3.13 给字符串填充0

data = "alex"
v1 = data.zfill(10)
print(v1) # 000000alex
# 应用场景：处理二进制数据
data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"

10.3.14 公共功能

1、相加，字符串拼接

2、相乘，字符串 * 整数

3、长度

data = "zed"
print(len(data)) # 3

4、获取字符串中的字符，索引

message = "北京欢迎你"
print(message[0]) # 北
print(message[1]) # 京
print(message[2]) # 欢

字符串中是能通过索引取值，无法修改值；

5、获取字符串中的子序列，切片

message = "就像阳光穿破黑夜"
print(message[0:2]) # 就像
print(message[2:]) # 阳光穿破黑夜
print(message[:2]) # 就像

print(message[6:-1]) # 黑
print(message[6:len(message)]) # 黑夜

字符串切片自己读取数据，无法修改数据

6、步长，跳着取字符串的内容

name = "生活不是电影，生活比电影苦"

print( name[ 0:5:2 ] )   # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】
print( name[ :8:2 ] )    # 输出：生不电，  【区间范围的前面不写则表示起始范围为0开始】、
# print( name[ 2::2 ] )    # 输出：不电，活电苦
# print( name[ 2::3 ] )    # 输出：不影活影

print( name[ 2::3 ] )    # 输出：不电，活电苦 【区间范围的后面不写则表示结束范围为最后】
print( name[ ::2 ] )     # 输出：生不电，活电苦 【区间范围不写表示整个字符串】
print( name[ 8:1:-1 ] )  # 输出：活生，影电是不 【倒序】

7、循环

• while循环

message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
index = 0
while index < len(message):
	print(message[index])
	index += 1

• for循环

message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
for char in message:
    print(char)

• range：帮助创建一系列数字

range(10) # [0,1,2,3,4,5,6,7,8,9]
range(1, 10) # [1,2,3,4,5,6,7,8,9]
range(1, 10, 2) #[1,3,5,7,9]
range(10, 1, -1) # [10,9,8,7,6,5,4,3,2]

• for + range:

for i in range(10)
	print(i)
message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
for i in range(5):
    print(message[i])
####################
for i in range(len(message)):
    print(message[i])

10.3.15 字符串类型转换

num = 999
data = str(num)
print(data) # "999"

10.3.16 字符串不可被修改

name = "Alan"

11.4 列表(list)

列表(list)，是一个可变的容器，在里面可以存放多个不同类型的元素

11.4.1 定义

user_list = ["李白","苏轼","辛弃疾"]
number_list = [92,93,94,95]
data_list = [1,True,"Alan", "张楚岚"]

user_list = []
user_list.append("盖聂")
user_list.append(123)
user_list.append(False)
print(user_list) # ["盖聂",123,False]

不可变类型：字符串、布尔、整型

可变类型：列表

11.4.2 独有功能

1、追加，在原有列表中尾部追加值

data_list = []
data_list.append("s1")
data_list.append("s2")

2、批量追加，将一个列表中的元素逐一添加到另外一个列表

tools = ["板砖","菜刀"]
weapon = ["AK47","MP5"]
tools.extend(weapon)

print(tools)

3、插入，在原列表的指定索引位置插入值

user_list = ["李白","杜甫","白居易"]
user_list.insert(1,"王维") # ["李白","王维","杜甫","白居易"]

4、在原列表中根据值删除（从左到右找到第一个删除，慎用！里面没有会报错）

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
if "孙笑川" in user_list:
	user_list.remove("孙笑川")
print(user_list)

5、在原列表中根据索引删除某个元素（根据索引位置删除）

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.pop(1) # 删除索引为1的元素
user_list.pop() #删除最后一个元素 ["李白","辛弃疾"]

item = user_list.pop()

6、清空原列表

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.clear()
print(user_list) # []

7、根据值获取索引（从左到右找到第一个，慎用！找不到会报错）

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
if "孙笑川" in user_list:
	index = user_list.index("孙笑川")
print(index) # 3

8、列表元素排序

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.sort()
print(user_list) # 默认从小到大排序
print(user_list.sort(reverse=True)) # 从大到小排序
# 注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）

9、反转原列表

user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.reverse()
print(user_list) # 列表会反转

11.4.3 公共功能

1、相加，两个列表相加获取生成一个新的列表

data_list1 = ["李白","杜甫"]
data_list2 = ["苏轼","辛弃疾"]

data_list3 = data_list1 + data_list2
print(data_list3) # ["李白","杜甫","苏轼","辛弃疾"]

2、相乘(列表*整型，将列表中的元素再创建N份并生成一个新的列表)

data_list = ["李白","杜甫"] * 2
print(data_list) # ["李白","杜甫","李白","杜甫"]

3、运算符in包含

由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中

user_list = ["李白","杜甫","苏轼","白居易"]
result1 = "白居易" in user_list
result2 = "辛弃疾" in user_list
print(result1) # True
print(result2) # False

4、获取长度

user_list = ["李白","杜甫","苏轼","白居易"]
print(len(user_list)) # 4

5、索引

user_list = ["李白","杜甫","苏轼","白居易"]
print(user_list[3]) # 白居易
del user_list[0] #删除第0个元素

6、切片

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']

print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )

# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']

# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']

7、步长

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
#              0        1        2          3       4
print( user_list[1:4:2] ) # 刘华强 宋小宝
print( user_list[0::2] ) # 
print( user_list[1::2] ) # 
print( user_list[4:1:-1] ) # 刘能 宋小宝 尼古拉斯赵四

# 案例：实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data)


data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list)

# 给你一个字符串请实现字符串的翻转？
name = "12345"
name[::-1]

8、for循环

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
	print(item)

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]

for index in range( len(user_list) ):
    item = user_index[index]
    print(item)

切记，循环的过程中对数据进行删除会踩坑

# 错误方式， 有坑，结果不是你想要的。

user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)
        
print(user_list)
# 正确方式，倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

11.4.4 转换

• int、bool无法转换成列表
• 字符串转成列表没有意义；

name = "苏东坡"
list(name) # ["苏","东","坡"]

• 元组、集合转成list

v1 = (11,22,33,44)
vv1 = list(v1) # [11,22,33,44]

v2 = {"alex", "alan","otto"}
vv2 = list(v2) # ["alex", "alan", "otto"]

11.4.5 其他

嵌套

data = ["赵四",["1","2","3"],True, [11,22,[33,44]]]

11.5 元组(tuple)

列表（list）：是一个有序且可变的容器，在里面可以存放多个不同类型的元素；

元组（tuple）：是一个有序且不可变的容器，在里面可以存放多个不同类型的元素；

11.5.1 定义

v1 = (11,22,33)
v2 = ("小明","Alan")
v3 = (True,123,"Alex",[11,22,33])
# 建议：在元组的最后一个元素后面多加一个逗号，用来表示它是一个元组
v3 = ("Alan",11, ) 

11.5.5 公共功能

1、相加，两个列表相加获取一个新的元组

v1 = ("小明","小亮")
v2 = ("张三","李四")
v3 = v1 + v2
print(v3) # ("小明","小亮","张三","李四", )

2、相乘，列表*整型，将列表中的元素再创建N份

v1 = ("小明","小亮")
print(v1*2)

3、获取长度

user_tuple = ("小明","小亮","张三")
print(len(user_tuple)) # 3

4、索引

user_tuple = ("小明","小亮","张三")
print(user_tuple[1]) #小亮

5、切片

user_tuple = ("小明","小亮","张三")
print(user_tuple[0:2]) # 小明 销量

6、步长

user_tuple = ("小明","小亮","张三","李四","王五")
print(user_tuple[1:4:2])
print(user_tuple[4:1:-1])
# 反转tuple
new_user_tuple = user_tuple[::-1]
print(new_user_tuple)

7、for循环

user_tuple = ("小明","小亮","张三","李四","王五")
for item in user_tuple:
    print(item)

for item in user_tuple:
    if item == "张三":
        continue
    print(item)

目前，只有str、list、tuple可以被for循环

11.5.3 转换

其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组

data = tuple(其他)
# str/list

11.5.4 嵌套

由于元组和列表都可以充当容器，他们内部也可以放多个元组，并且也支持元素内的嵌套

12.6 set集合

set集合：无序、可变、不允许数据重复的容器

12.6.1 定义

v1 = {1,"22",True,"Alex"}

• 无序：无法通过索引定位值

• 可变：可以添加和删除元素

  v1 = {11,22,33}
  v1.add(44)
  print(v1) # {11,22,33,44}
  

• 不允许数据重复

  v1 = {11,22,33}
  v1.add(11)
  print(v1) # 11 22 33
  

什么时候用到集合：

想要维护一大堆不重复的数据的时候，就可以用它，比如：做爬虫去网上找图片链接时，为了避免数据重复，可以选择用集合去存储链接地址

注意：定义空集合时候，只能使用v=set{},不能使用v={}(这样定义是一个空字典)

12.6.2 独有功能

1、添加元素

data = {"苏东坡","白居易","辛弃疾"}
data.add("欧阳修")
print(data)

data = set()
data.add("周杰伦")
data.add("薛之谦")
print(data)

2、删除元素

data = {"苏东坡","白居易","辛弃疾","王富贵"}
data.discard("王富贵")
print(data)

3、交集

s1 = {"苏东坡","白居易","辛弃疾","王富贵"}
s2 = {"李白","杜甫","王勃","王富贵"}
s3 = s1 & s2 #取两个集合的交集
s4 = s1.intersection(s2) # 王富贵
print(s3,s4)

4、并集

s1 = {"苏东坡","白居易"}
s2 = {"李白","杜甫"}
s3 = s1 | s2
s4 = s1.union(s2)
print(s3,s4)

5、差集

s1 = {"刘能","赵四","皮常山"}
s2 = {"刘科长","赵市长","皮常山"}
s3 = s1 - s2 #取差集，s1中有且s2中没有的值
s3 = s1.difference(s2) #取差集，s1中有且s2中没有的值

12.6.3 公共功能

1、减，计算差集

2、&，取交集

3、|，计算并集

4、长度

v1 = {"张三","李四","王五"}
data = len(v1)
print(data)

5、for循环

v1 = {"张三","李四","王五"}
for item in v1:
    print(item)

12.6.4 转换

其他类型如果想转换成集合类型，使用set(其他类型)，如果数据有重复会自动删除

注意： int/list/tuple/dict都可以转换为集合

12.6.5 其他

12.6.5.1 集合的存储原理

12.6.5.2 元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。

目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。

总结：集合的元素只能是 int、bool、str、tuple 。

• 转换成功

  v1 = [11,22,33,11,3,99,22]
  v2 = set(v1)
  print(v2) # {11,22,33,3,99}
  

• 转换失败

  v1 = [11,22,["alex","eric"],33]
  v2 = set(v1) # 报错 
  print(v2) 
  

12.6.5.3 查找速度特别快

user_set = {"苏东坡","alex","李璐"}
if "alex" in user_set:
    print("在")
else:
    print("不在")

12.6.5.4 对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[]或v=list()
tuple	否	是	无	是	tuple(其他)	v=()或v=tuple()
set	是	否	可哈希	否	set(其他)	v=set()

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # {True}

v2 = {1, True}
print(v2)  # {1}

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}

None类型

Python中有一个特殊的值None类型，表示为空

目前可以转换为False的值有：

0
""
[] or list()
() or tuple()
set()
None

12.7 dict字典类型

字典是无序、键不重复且元素只能是键值对的可变的容器

• 容器

• 元素必须是键值对

• 键不重复，重复则会被覆盖

  data = {"k1": 1, "k1": 2}
  print(data) # {"k1": 2}
  

• 无序（python3.6+之后字典就是有序了，之前字典是无序的）

12.7.1 定义

d1 = {}
d2 = dict()

info = {
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}

字典中对键值对的要求：

• 键: 必须是可哈希的，目前是: int/bool/str/tuple，不可哈希的类型：list/set/dict;
• 值：任意类型；

12.7.2 独有功能

1、获取值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}

age = info.get("age")
print(age)

name = info.get("name")
print(name)

address = info.get("address")
print(address) # None

birth = info.get("birth", "2001-01-28")
print(birth) # 2001-01-28

# 案例
user_list = {
    "alex": "123",
    "admin": "123456"
}

username = input("请输入用户名: ")
password = input("请输入密码: ")
pwd = user_list.get(username)

if pwd == None:
    print("用户名不存在")
else:
    if pwd == password:
        print("登录成功")
    else:
        print("密码错误")
# 写代码的准则：简单的逻辑放在前面，复杂的逻辑放在后面

2、获取所有的键

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
data = info.keys()
print(data) # 输出(["name","age","sex","status","hobby"]) 高仿列表
print(list(data))

注意：在python2中字典.keys()直接获取到的是列表，而python3中返回的是高仿列表，高仿列表可以被循环显示

for key in info.keys():
    print(key)
# 判断某个key是否存在字典中
if "age" in info.keys():
    print("age是字典的键")

3、获取所有的值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
data = info.values()
print(data) # dict_value(["Alan",12,"male","True",["游戏",读书]])

注意：在python2中字典.values()直接获取到的是列表，而python3中返回的是高仿列表，高仿列表可以被循环显示

for value in info.values():
    print(value)
if 12 in info.values():
    print("12是字典的值")

4、获取所有的键值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
data = info.items()

print(data) # 输出dict_items() ([('age', 12),("name",Alan),....])

for item in info.items():
    print(item) #item是一个元组
    print(item[0],item[1])
# -------------------
for key,value in info.items():
    print(key,value) #key代表键，value代表值

5、设置值

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
# 没有这个键值是添加，有这个键的话是修改
data.setdefault("salary","15000")

6、批量更新键值对

info = {
    "name": "Alan"
    "age": 12,
    "sex": "male",
    "status": True,
    "hobby": ["游戏", "读书"]
}
info.update({"age": 18, "name": "Bob"})
print(info) # info中没有的键则直接添加，有的键则是更新值，主打一个批量更新

7、指定移除键值对

info = {"age": 12, "status": True, "name": "Alex"}
data = info.pop("age")
print(info) # {"status": True, "name": "Alex"}
print(data) # 12

8、按照顺序移除（后进先出）

info = {"age": 12, "status": True, "name": "Alex"}
data = info.popitem()
print(info) # {"age": 12, "status": True}
print(data) # {"name": "Alex"}

# 练习题
"""
结合下面的两个变量 header 和 stock_dict实现注意输出股票信息，格式如下：
	SH601778，股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。
    SH688566，股票名称:吉贝尔、当前价:...               。
	...
"""
header = ['股票名称', '当前价', '涨跌额']
stock_dict = {
    'SH601778': ['中国晶科', '6.29', '+1.92'],
    'SH688566': ['吉贝尔', '52.66', '+6.96'],
    'SH688268': ['华特气体', '88.80', '+11.72'],
    'SH600734': ['实达集团', '2.60', '+0.24']
}

for key,value in stock_dict.items():
    # 'SH601778', ['中国晶科', '6.29', '+1.92']
    textList = list()
    for index in range(len(header)):
        str = "{0}: {1}".format(header[index],value[index])
        textList.append(str)
    print("{0}, {1}".format(key, ", ".join(textList)))

12.7.3 公共功能

1、求并集（python3.9加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}

v3 = v1 | v2
print(v3) # {"k1": 1, "k2": 22, "k3": 33}

2、长度

info = {"age": 12, "status": True, "name": "Alex"}
print(len(info)) # 3

3、是否包含

info = {"age": 12, "status": True, "name": "Alex"}
v1 = "age" in info
print(v1) # true

v2 = "age" in info.keys()

4、索引(键)

字典区别于元组和列表，字典的索引是键，而列表和元组则是0 1 2

info = {"age": 12, "status": True, "name": "Alex"}
print(info["age"]) # 输出12
print(info["staus"]) # 输出True
print(info["xxx"]) # 报错

# 建议使用 info.get("key")

5、根据键修改值和添加值和删除键值对

info = {"age": 12, "status": True, "name": "Alex"}
info["gender"] = "男"
print(info) #{"age": 12, "status": True, "name": "Alex","gender": "男"}

info = {"age": 12, "status": True, "name": "Alex"}
del info["age"] # 保证键存在，才能删除
print(info) # {"status": True, "name": "Alex"}

6、for循环

info = {"age": 12, "status": True, "name": "Alex"}
for key in info.keys():
    print(key)
for value in info.values():
	print(value)
for key,value in info.items():
    print(key, value)

12.7.4 转换

想要转换为字典.

v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )

print(v) # { "k1":"v1", "k2":"v2" }

info = { "age":12, "status":True, "name":"武沛齐" }

v1 = list(info)        # ["age","status","name"]

v2 = list(info.keys()) # ["age","status","name"]

v3 = list(info.values()) # [12,True,"武沛齐"]

v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]

12.7.5 其他

12.7.5.1 存储原理

12.7.5.2 速度快

info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
for "alex" in info:
    print("在"）

info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")

12.7.6 嵌套

我们已学了很多数据类型，在涉及多种数据类型之间的嵌套时，需注意一下几点：

• 字典的键必须可哈希（list/set/dict不可哈希）。

  info = {
      (11,22):123
  }
  
  # 错误
  info = {
      (11,[11,22,],22):"alex"
  }
  

• 字典的值可以是任意类型。

  info = {
      "k1":{12,3,5},
  	"k2":{"xx":"x1"}
  }
  

• 字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。

• 元组的元素不可以被替换。

dic = {
	'name':'汪峰',
	'age':48,
	'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],
	'children':['第一个娃','第二个娃']
}
"""
1. 获取汪峰的妻子名字
	d1 = dic['wife'][0]['name']
	print(d1)
2. 获取汪峰的孩子们
	d2 = dic['children']
	print(d2)
3. 获取汪峰的第一个孩子
	d3 = dic['children'][0]
	print(d3)
4. 汪峰的媳妇姓名变更为 章子怡
	dic['wife'][0]['name] = "章子怡"
	print(dic)
5. 汪峰再娶一任妻子
	dic['wife'].append( {"name":"铁锤","age":19} )
	print(dic)
	
6. 给汪峰添加一个爱好：吹牛逼
	dic['hobby'] = "吹牛逼"
	print(dic)
7. 删除汪峰的年龄
	del dic['age']
	或
	dic.pop('age')
	print(dic)
"""

12.8 float浮点型

v1 = 3.14
v2 = 9.99

• 在类型转换时，浮点型转为整型，会将小数部分去掉

v1 = 3.4
print(int(v1)) # 3

• 保留小数点后N位

v1 = 3.1415926
print(round(v1, 3)) # 3.142

• 浮点型的坑

  

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3