Python基础语法知识

基础语法

基本的输出函数

语法结构：

print(输出内容)

说明：

• 输出内容可以是数字和字符串（字符串需要使用引号引起来），此内容将直接输出，也可以是包含运算的表达式，若是表达式则将计算结果输出
• 如果想要一次输出多个内容，而且不换行，则可以使用英文半角的逗号将要输出的内容进行分割；如果需要换行

基本的输入函数

语法结构：

variable = input('提示输入内容的文字')

说明：

• 无论用户输入的是字符还是数字，input()函数统一按照字符串类型进行输出
• 想要接受整形的数字，需要用变量接收

number = int(input('请输入一个数字：'))

注释

什么是注释：

• 是指程序员在代码中对代码功能解释说明的标注性文字，可以提高代码的可读性
• 注释的内容将被Python解释器忽略，不被计算执行

注释的分类：

1. 单行注释
   以"#“作为单行注释的符号，作用范围内从”#"开始到换行为止

# 这是单行注释

2. 多行注释
   Python中并没有单独的多行注释标记，将包含在一对三引号之间的代码称为多行注释

"""
这是多行注释
"""

'''
这也是多行注释
'''

4. 中文声明注释

# 以下三种在py文件第一行写一种就行
# coding:utf-8
# coding=utf-8
# -*- coding: utf-8 -*-

代码缩进

• Python语言采用严格的"缩进"来表示程序的逻辑关系
• 缩进是指每行语句开始前的空白区域，用来表示Python程序间的包含和层次关系
• 一般代码不需要进行缩进，顶行编写且不留空白
• 类定义，函数定义，流程控制语句，以及异常处理处理语句等，行尾的冒号和下一行的缩进表示一个代码块的开始，而缩进结束，则表示一个代码块的结束
• 缩进可以使用空格键或者Tab键实现，通常情况下采用4个空格或者一个Tab作为一个缩进量

保留字

• 保留字是Python已经被赋予特定意义的一些单词，在程序开发时，不可以用这些保留字作为变量，函数，类，模块和其他对象的名称来使用
• Python中的保留字是严格区分大小写的
• 首字母大写的只有True和False以及None

Python中保留字如下：

and	as	assert	break	class	continue
def	del	elif	else	except	finally
for	from	False	global	if	import
in	is	lambda	nonlocal	not	None
or	pass	raise	return	try	True
while	with	yield

标识符

标识符可以简单的理解为一个名字。它主要用来标识变量，函数，类，模块和其他对象的名称
Python标识符的命名规则：

1. 可以是字母，下划线"_"和数字，并且第一个字符不能是数字
2. 不能使用Python中的保留字
3. 标识符严格区分大小写
4. 以下划线开头的标识符有特殊意义，一般应避免使用类似的标识符
5. 允许使用中文作为标识符，但不建议使用

标识符的命名规范：

1. 模块名尽量短小，并且全部使用小写字母，可以使用下划线分割多个单词。例如：game_main
2. 包名尽量短小，并且全部使用小写字母，不推荐使用下划线。例如：com.sykj，不推荐使用com_sykj
3. 类名采用单词首字母大写形式。例如：MyClass
4. 模块内部的类采用"_" + 大驼峰命名规则的类名组成。例如：在MyClass中的内部类_InnerMyClass
5. 函数，类名的属性和方法的命名，全部使用小写字母，多个单词之间使用下划线分隔
6. 常量命名时采用全部大写字母，可以使用下划线
7. 使用单下划线"_"开头的模块变量或者函数是受保护的，在使用"from xxx import *"语句从模块中导入时，这些模块变量或者函数不能被导入
8. 使用双下划线"__"开头的实例变量或者方法是类私有的
9. 以双下划线开头和结尾的是Python的专用标识。例如__init__()表示初始化函数

变量

语法结构：

# 变量名 = value
num = 12

• Python是一种动态类型的语言，变量的类型可以随时变化（使用内置函数type()可以查看变量的数据类型）
• 允许多个变量指向同一个值（使用内置函数id()可以返回变量所指的内存地址）

变量命名应遵循以下的几条规则：

• 变量名必须是一个有效的标识符
• 变量名不能使用Python中的保留字
• 慎用小写字母l和大写字母O（看起来像1和0）
• 应选择有意义的单词作为变量名（见名知意）

常量：

• 常量就是在程序运行过程中值不能改变的量
• Python中没有定义常量的保留字
• 常量规定使用大写字母和下划线组成
• 常量首次赋值后，还是可以被其他代码修改的

数据类型

Python中的数据类型分类：

说明：

1. 布尔型（bool）
   真 True 非0数 --非零即真
   假 False 0
2. 复数型（complex）
   主要用于科学计算。例如：平面场问题，波动问题，电感电容问题

非数字型变量的特点：

1. 都是一个序列（sequence），也可以理解为容器
2. 取值 []
3. 遍历 for in
4. 计算长度，最大/最小值，比较，删除
5. 连接 + 和重复 *
6. 切片

数字型

整数类型

• 表示整数数值，即没有小数部分的数值
• 正整数，负数和0
• 理论上的取值范围[负无穷，正无穷]
• 整数的表示形式
• 不可变数据类型

各进制说明：

进制种类	引导符号	描述
十进制	无	默认情况，例如：365,767
二进制	0b或者0B	由字符0和1组成，例如：0b10101，0B1010
八进制	0o或者0O	由字符0到7组成，例如：0o763，0O657
十六进制	0x或者0X	由字符0到9，a到f或A到F组成，例如：0x987A，0X965B

不同进制之间的转换

• 十进制转其他进制使用短除法,除以需要转换的进制,余数由下向上;
• 其他进制转十进制由右向左依次加1次幂之和;
  

浮点数类型

• 表示带有小数点的数值
• 浮点数由整数部分和小数部分组成
• Python中浮点数类型必须带有小数部分，小数部分可以是0
• 浮点数可以使用科学计数法表示
• 两个浮点数运算，有一定的概率运算结果后增加一些不确定的尾数
• 使用内置函数round()限定运算结果需要保留的小数位数
• 不可变数据类型

布尔类型

• 用来表示真值或者假值
• 在Python中使用标识符True和False表示布尔类型的值
• 布尔类型可转换为数值，True表示1 False表示0
• 所有对象都有一个布尔值，使用内置函数bool()进行查看

布尔值为假的情况：

• False或者是None
• 数值中的0，包括0，0.0，虚数0
• 空序列，包含空字符串，空元祖，空列表，空字典
• 自定义对象的实例，该对象的__bool__()方法返回False或者__len__()方法返回0

复数类型

• Python中的复数与数学中的复数形式完全一致
• 复数分为实部和虚部
• j是复数的一个基本单位，被定义为j = -1开平方（这里根号敲不出来就文字描述一了），又称虚单位
• .real获取实数部分，.imag获取虚数部分
• 不可变数据类型

数据类型之间的转换

隐式类型转换
通过数学运算可以隐式将int类型转换成float类型

显式类型转换

函数	说明
int(x[,base])	将x转换为一个整数
float(x)	将x转换为一个浮点数
complex(real[,imag])	创建一个复数，real为实部，imag为虚部
str(x)	将对象x转换为字符串
repr(x)	将对象x转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式，并返回一个对象
tuple(s)	将序列s转换为一个元祖
list(s)	将序列s转换为一个列表
chr(x)	将一个整数转换为一个Unicode字符
ord(x)	将一个字符转换为它的ASCLL整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串
bin(x)	将一个整数转换为一个二进制字符串

eval()函数

eval(s)函数将去掉字符串s最外侧的引号，并按照Python
语句方式执行去掉引号后的字符串

语法格式：
eval()函数经常和input()函数一起使用，用来获取用户输入的数值

# 语法格式：
# 变量 = eval(字符串)
add = eval("1 + 1")
print(add) # 2

string = eval("'*' * 10")
print(string) # **********

lis = type(eval("[1,2,3,4,5]"))
print(lis) # <class 'list'>

dic = type(eval("{'name':'zhangsan','age':18}"))
print(dic) # <class 'dict'>

不要滥用eval
在开发时千万不要使用eval直接转换input的结果

__import__('os').system('rm -rf /*')
# 等价代码
import os
os.system("rm -rf /*")
# 执行成功，返回0
# 执行失败，返回错误信息

序列结构

• 序列是一个用于存储多个值的连续空间，每个值都对应一个 整数的编号，也称为索引
• 序列结构主要有列表，元祖，集合，字典和字符串

索引：

• 正向递增索引，取值范围[0,N-1]
• 反向递减索引，取值范围[-1,-N]
  

序列的相关操作

切片操作

切片操作是访问序列元素的另一种方法，它可以访问一定范围内的元素。通过切片操作可以生成一个新的序列

语法结构：

# 序列[start:end:step]
"""
参数说明：
start：表示切片的开始位置（包括开始位置），如果不指定，默认为0
end：表示切片的结束位置（不包括结束位置），如果不指定，默认为程序的长度
step：表示步长，如果省略，默认为1，当省略步长时，最后一个冒号可以省略
提示：
	1.当end参数不指定时，语法中的第一个：不可以省略，否则会报错
	2.step参数可以为复数。例如：字符串切片时step传-1，字符串就可以倒过来
"""

序列的相加

使用"+"实现两个同类型的序列的相加操作，不会去除重复元素

print("Hello" + "World")
# HelloWorld
"""
注意事项：
	序列的类型要求是要相同的，但是序列中元素的类型可以是不同的
"""

序列的相乘

使用数字n乘以一个序列，将生成一个新的序列，新序列中的内容会被重复n次

print("*" * 20)
# ********************

序列的相关操作符与函数

操作符	描述
x in s	如果x是s的元素，结果为True,否则结果为False
x not in s	如果x不是s的元素，结果为True，否则结果为False
len(s)	序列s中元素的个数(即序列的长度)
max(s)	序列s中元素的最大值
min(s)	序列s中元素的最小值
s.index(x)	序列s中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

字符串

• 字符串就是连续的字符序列，可以表示计算机所能识别的一切字符
• 单行字符串使用’…'或者"…"
• 多行字符串使用’’’…’’'或者"""…"""
• 不可变数据类型，即不可变字符序列

转义字符

• 反斜杠字符()是一个特殊的字符，在Python字符串中表示"转义"，该字符与后面相邻的一个字符共同组成一个新的含义
• 在字符串界定符前加上r或R，转义字符失效，将原样输出

转义字符	说明
\n	换行符
\t	水平制表位，用于横向跳到下一个制表位
\"	双引号
\’	单引号
\\	一个反斜杠

字符串的索引

对字符串中某个字符的检索称为索引

语法结构：

# 字符串或者字符串变量[序号]
"HELLOWORLD"[5] # W

字符串的切片

对字符串中某个子串或者区间的检索称为切片

语法结构：

# 字符串或者字符串变量[N:M]
"HELLOWORLD"[5:8] # WOR

• 切片获取字符串中从N到M（不包括M）的子字符串
• N默认为0
• M默认切到字符串结尾

字符串类型操作

操作符	描述
x + y	连接两个字符串x与y
x * n 或 n * x	复制n次字符串
x in s	如果x是s的子串结果为True，否则结果为False

格式化字符串

如果希望输出文字信息的同时，一起输出数据，就需要用到格式化操作符

• %被称为格式化操作符，专门用于处理字符串中的格式
• 包含%的字符串，被称为格式化字符串
• %和不同的字符连用，不同类型的数据需要使用不同格式化字符

格式符号	转换
%s	字符串
%d	有符号的十进制整数(%06d，表示输出的整数显示位数，不足的以0补全，超出当前位数则原样输出)
%f	浮点数(%.2f，表示小数点后显示的小数位数)
%c	字符
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数(小写0x)
%X	十六进制整数(大写0X)
%e	科学计数法(小写e)
%E	科学计数法(大写E)
%g	%f和%e的简写
%G	%f 和 %E 的简写

语法格式：

print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1，变量2，.....))

内置函数format
format()用于字符串格式化，功能十分强大；格式是str.format(),format函数可以接受多个参数，位置可以不按顺序

# 基础用法
"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
# 'hello world'
 
"{0} {1}".format("hello", "world")  # 设置指定位置
# 'hello world'
 
"{1} {0} {1}".format("hello", "world")  # 设置指定位置
# 'world hello world'

# 设置参数
print("网站名：{name}, 地址 {url}".format(name="CSDN", url="https://www.csdn.net/"))
# 网站名：CSDN, 地址 https://www.csdn.net/
 
# 通过字典设置参数
site = {"name": "CSDN", "url": "https://www.csdn.net/"}
print("网站名：{name}, 地址 {url}".format(**site))
# 网站名：CSDN, 地址 https://www.csdn.net/
 
# 通过列表索引设置参数
my_list = ['CSDN', 'https://www.csdn.net/']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
# 网站名：CSDN, 地址 https://www.csdn.net/

# 数字格式化
print("{:.2f}".format(3.1415926))
# 3.14

f格式化字符串
f格式化字符串是格式化字符串的一种很好的新方法
语法格式：

f'{表达式}'

格式化字符串示例：

name = "张三"
age = 23
weight = 75.5
student_id = 1

print('我的名字是%s' % name)
# 我的名字是张三

print('我的学号是%04d' % student_id)
# 我的学号是0001

print('我的体重是%.2f公斤' % weight)
# 我的体重是75.50公斤

print('我的名字是%s，今年%d岁了' % (name, age))
# 我的名字是张三,今年23岁了

print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 我的名字是张三,今年24岁了

print('我的名字是{0}，明年{1}岁了'.format(name, age + 1))
# 我的名字是张三,明年24岁了

print('我的名字是{0}，今年{1}岁了'.format('李四', 18))
# 我的名字是李四,今年18岁了

print(f'我的名字是{name},明年{age + 1}岁了')
# 我的名字是张三,明年24岁了

补充知识：
字符串输出的本质其实就是拼接字符串，那么我们都用%s完全也是可以的。很多时候我们不用区分整型，浮点型等，直接用%s输出就可以了

print('我的名字是%s，今年%s岁了，我的体重是%s公斤' % (name, age, weight))
# 我的名字是张三，今年23岁了，我的体重是75.5公斤

列表

• 一系列按特定顺序排列的元素组成
• 使用[]定义列表，元素之间使用逗号分割
• 元素可以是任意的数据类型
• Python中内置的可变序列

列表的创建

语法格式：

# 使用[]直接创建列表
# 列表名 = [元素1，元素2，... , 元素N]
lis = ["123", "234", 97]
print(lis)
# ['123', '234', 97]

# 使用内置方法list()创建列表
# 列表名 = list(序列)
lis = list(["123", "234", 97])
print(lis)
# ['123', '234', 97]

列表的删除

语法格式：

# del  列表名
del lis

列表的生成式

语法格式：

# 生成指定范围的数值列表
# lst = [表达式 for item in range]
import random

lst = [item for item in range(1, 11)]
print(lst) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 从列表中选择符合条件的元素组成新的列表
# lst = [表达式 for item in 列表 if 条件语句]
# 不带if 条件语句
lst = [item * item for item in range(1, 11)]
print(lst) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

lst = [random.randint(1, 100) for item in range(10)]
print(lst) # [70, 51, 76, 100, 99, 83, 38, 56, 81, 77]

# 带if 条件语句
lst = [i for i in range(10) if i % 2 == 0]
print(lst) # [0, 2, 4, 6, 8]

列表元素的遍历

使用遍历循环for

语法格式：

# 遍历循环for与range()函数和len()函数组合遍历
"""
for 循环变量 in 遍历对象：
	语句块
"""
lst = [item for item in range(1, 6)]
for item in lst:
    print(item)
"""
输出：
1
2
3
4
5
"""
# 遍历循环for与enumerate()函数组合遍历元素和索引
"""
for index，item in enumerate(lst)：
	输出index和item
"""
# index：用于保存元素的索引
# item： 用于保存获取到的元素值
for index, item in enumerate(lst): # 默认序号从0开始
    print(index, item)
"""
输出：
0 1
1 2
2 3
3 4
4 5
"""

for index, item in enumerate(lst, 1): # 序号从1开始
    print(index, item)
"""
输出：
1 1
2 2
3 3
4 4
5 5
"""

列表的相关操作方法

方法	描述
lst.append(x)	在列表lst最后增加一个元素
lst.insert(index, x)	在列表中第index位置增加一个x元素
lst.clear()	清除列表lst中所有元素
lst.pop(index)	将列表lst中第index位置的元素取出，并从列表中将其删除
lst.remove(x)	将列表lst中出现的第一个元素x删除
lst.reverse()	将列表lst中的元素反转
lst.copy()	拷贝列表lst中的所有元素，生成一个新的列表

列表元素的修改

语法格式：

# 列表名称[index] = "修改的值"
lst = [item for item in range(1, 6)]
print(lst)
lst[2] = 99
print(lst)
"""
输出：
[1, 2, 3, 4, 5]
[1, 2, 99, 4, 5]
"""

列表的排序

下面的排序方式也适用于其他序列类型

语法格式：

# 列表对象的sort()方法
# 说明：对原列表中的元素进行排序，排序之后原列表中元素的顺序将发生改变
"""
lst.sort(key=None, reverse=False)
参数说明：
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）
"""

# 内置的sorted()函数
# 使用sorted()函数排序后，原列表的元素顺序不变，排序后产生一个新的列表对象
"""
sorted(iterable, key=None, reverser=False)
参数说明：
iterable -- 表示指定的序列
key -- 参数可以自定义排序规则
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）
"""

二维列表

二维列表也称表格数据，由行和列组成

城市	环比	同比	定基
北京	103.5	138.5	127.5
上海	103.3	107.8	130.3
深圳	100.3	123.3	123.3

二维列表的遍历：

"""
for row in 二维列表：
	for item in row:
		pass
"""

# 生成一个四行五列的二维列表
lst = [[j for j in range(5)] for i in range(4)]
print(lst)
"""
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
"""

元组

• 由一系列按特定顺序排列的元素组成
• 使用()定义，元素之间使用逗号分割
• 元组中的元素可以是任意数据类型
• Python中的不可变序列

元组的创建

语法格式：

# 使用()直接创建元组	
"""
tips:
	1.小括号可以省略
	2.如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数 1，(1,)才解释为元组
"""
tu = (12, "3435", "hello")
print(tu)

tu2 = 12, "3435", "hello"
print(tu2)
# (12, '3435', 'hello')
# (12, '3435', 'hello')

# 使用内置函数tuple()创建元组
tu3 = tuple("abcd")
print(tu3)
# ('a', 'b', 'c', 'd')

tu4 = tuple(range(3))
print(tu4)
# (0, 1, 2)

tu5 = tuple([10, 20, 30])
print(tu5)
# (10, 20, 30)

元组的删除

语法格式：

# del 元组名

元组的元素遍历

与列表的遍历方式相同

元组生成式

语法格式：
注意：

1. 元组生成式的结果是一个生成器对象，需要转换成元组或者列表才能查看到元素的内容
2. 生成器遍历后，再想重新遍历必须新创建一个生成器对象，因为遍历后原来的生成器对象已经不存在了

# 生成指定范围的数值列表
# tu = (表达式 for item in range)
import random

gen = (item for item in range(1, 11))
tu = tuple(gen)
print(tu)
# (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# 从元组中选择复合条件的元组组成新的元组 
# tu = (表达式 for item in 元组 if 条件语句)
# 不带if 条件语句
gen = (item * item for item in range(1, 11))
tu = tuple(gen)
print(tu) 
# (1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

gen = (random.randint(1, 100) for item in range(10))
tu = tuple(gen)
print(tu) 
# (88, 44, 82, 18, 85, 82, 37, 28, 82, 44)

# 带if 条件语句
gen = (i for i in range(10) if i % 2 == 0)
tu = tuple(gen)
print(tu) 
# (0, 2, 4, 6, 8)

元组与列表的区别

列表	元组
可变序列	不可变序列
append(),insert(),remove(),pop()等方法实现添加和删除列表元素	没有这几个方法，无法实现添加，删除和修改元素等操作
支持切片访问和修改列表中的元素	支持切片访问元素，不支持修改操作
访问和处理速度慢	访问和处理速度快
不能作为字典的键	可以作为字典的键

字典

键值对

根据一个信息查找另一个信息的方式构成了"键值对"，它表示索引有的键和对应的值构成的成对关系
例如：
身份证和具体的人的对应

字典的特征

• 通过键从字典中获取指定的项，但不能通过索引来获取
• 字典是无序的，也被称为hash表(散列表)
• 字典中的键必须是唯一，如果出现两次后，后出现的将覆盖先出现的
• 字典中的键要求是不可变序列
• 是Python中的可变序列

字典的创建

语法格式：

# 使用{}直接创建字典
# d = {key1：value,key2：value2,...}
d = {"123": "张三", 456: 3.14, (789): "012"}
print(d)
# {'123': '张三', 456: 3.14, 789: '012'}

# 使用内置函数dict()创建字典
  ## 通过映射函数创建字典
  ## zip(lst1,lst2)
lst1 = [1, 2, 3]
lst2 = ["张三", "李四", "王五"]
z = zip(lst1, lst2) # 这里返回的是一个<class 'zip'>
print(dict(z))
# {1: '张三', 2: '李四', 3: '王五'}

  ## 通过给定关键字创建字典
  ## dict(key1=value2,key2=value2,...)
  """
  tips: 
  1.数字写在key位置会报错，这里的key相当于变量名，而数字不能作为变量名
  2.key相当于变量名，变量名是不用加引号的
  """
d = dict(张三="100", 李四=120, 王五=150)
print(d)
# {'张三': '100', '李四': 120, '王五': 150}

字典元素的访问

语法格式：

# d[key]或者d.get(key)
"""
d[key]和d.get(key)的区别：
	如果d中不存在key时，d[key]会报错,d.get(key)会返回None,并且还可以指定默认值
	d = {1: "张三", 2: "李四", 3: "王五", 3: "赵六"}
	print(d.get(4, "越界啦"))
	输出：	越界啦
"""
d = {1: "张三", 2: "李四", 3: "王五", 3: "赵六"}
print(d[2])
print(d.get(3))
#print(d[4]) 会报错
print(d.get(4))
# 李四
# 赵六
# None

字典元素的遍历

语法格式：

"""
方式一：
for element in d.items():
	pass

方式二：
for key,value in d.items():
	pass
"""
d = {1: "张三", 2: "李四", 3: "王五", 3: "赵六"}
for ele in d.items():
    print(ele)

for k, v in d.items():
    print(k, v, sep="-->")
"""
输出：
(1, '张三')
(2, '李四')
(3, '赵六')
1-->张三
2-->李四
3-->赵六
"""

字典的相关操作方法

操作方法	描述
d.keys()	获取所有的key数据
d.values()	获取所有的value数据
d.pop(key,default)	key存在获取相对应的value，同时删除key-value对，否则获取default
d.popitem()	随机从字典中获取一个key-value对，结果为元组类型，同时将该key-value从字典中删除
d.clear()	清空字典中所有的key-value对

字典中添加数据

语法格式：

# 使用赋值运算符"="(等于号)，向字典中添加元素。修改也是同理
# d[key] = value
d = {1: "张三", 2: "李四", 3: "王五", 3: "赵六"}
print(d)
d[108] = "李逵"
print(d)
"""
{1: '张三', 2: '李四', 3: '赵六'}
{1: '张三', 2: '李四', 3: '赵六', 108: '李逵'}
"""

字典的生成式

语法格式：

# 使用指定范围的数作为key
# d = {key:value for item in range}
import random
d = {item: random.randint(1,100) for item in range(6)}
print(d)
# {0: 63, 1: 70, 2: 86, 3: 7, 4: 70, 5: 5}

# 使用映射函数生成字典
# d = {key:value for key,value in zip(lst1,lst2)}
lst1 = [1, 2, 3]
lst2 = ["张三", "李四", "王五"]
d = {k: v for k, v in zip(lst1, lst2)}
print(d)
# {1: '张三', 2: '李四', 3: '王五'}

集合

• Python中的集合与数学中集合的概念一致
• 集合可分为可变集合set与不可变集合frozenset
• 集合与字典中的key一致都是无序的
• 集合中的元素要求唯一
• 集合中只能存储不可变数据类型(字符串，整数，浮点数，元祖)
• 可变序列

集合的创建

语法格式：

# 使用{}直接创建
# s = {元素1,元素2,...,元素N}
s = {10, 20, 30}
print(s)
# {10, 20, 30}

# 使用内置函数set()创建集合
# s = set(可迭代对象)
s = set("helloworld")
print(s)
s = set([10, 20, 30])
print(s)
s = set(range(1, 10))
print(s)
"""
{'w', 'l', 'r', 'h', 'd', 'e', 'o'}
{10, 20, 30}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
"""

集合的删除

语法格式：

# del 集合名

集合类型的操作符

集合的相关操作方法

方法	描述
s.add(x)	如果x不在集合s中，则将x添加到集合s中
s.remove(x)	如果x在集合中，将其删除，如果不在集合中，程序报错
s.clear	清除集合中所有元素

集合的遍历

语法格式：

# 使用遍历循环for
s = set("helloworld")
for i in s:
    print(i)
"""
输出：
h
r
w
d
o
l
e
"""
# 使用for循环和enumerate()函数
s = set([10, 20, 30])
for index, item in enumerate(s):
    print(index, item, sep="-->")
"""
输出：
0-->10
1-->20
2-->30
"""

集合生成式

语法结构：

# 生成指定范围的数值集合
# s = {表达式 for item in range}
s = {i for i in range(5)}
print(s)
# {0, 1, 2, 3, 4}

# 从指定范围中选择符合条件的元素组成新的集合
# s = {表达式 for item in 范围 if 条件语句}
s = {i for i in range(10) if i % 2}
print(s)
# {1, 3, 5, 7, 9}

组合数据类型总结

列表，元组，字典，和集合的区别：

数据类型	序列类型	是否重复	是否有序	字义符号
列表list	可变序列	可重复	有序	[]
元组tuple	不可变序列	可重复	有序	()
字典dict	可变序列	key不可重复 value可重复	无序	{key:value}
集合set	可变序列	不可重复	无序	{}

Python其他语法后期再出一篇，敬请期待