基础语法
基本的输出函数
语法结构:
print(输出内容)
说明:
- 输出内容可以是数字和字符串(字符串需要使用引号引起来),此内容将直接输出,也可以是包含运算的表达式,若是表达式则将计算结果输出
- 如果想要一次输出多个内容,而且不换行,则可以使用英文半角的逗号将要输出的内容进行分割;如果需要换行
基本的输入函数
语法结构:
variable = input('提示输入内容的文字')
说明:
- 无论用户输入的是字符还是数字,input()函数统一按照字符串类型进行输出
- 想要接受整形的数字,需要用变量接收
number = int(input('请输入一个数字:'))
注释
什么是注释:
- 是指程序员在代码中对代码功能解释说明的标注性文字,可以提高代码的可读性
- 注释的内容将被Python解释器忽略,不被计算执行
注释的分类:
- 单行注释
以"#“作为单行注释的符号,作用范围内从”#"开始到换行为止
# 这是单行注释
- 多行注释
Python中并没有单独的多行注释标记,将包含在一对三引号之间的代码称为多行注释
"""
这是多行注释
"""
'''
这也是多行注释
'''
- 中文声明注释
# 以下三种在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标识符的命名规则:
- 可以是字母,下划线"_"和数字,并且第一个字符不能是数字
- 不能使用Python中的保留字
- 标识符严格区分大小写
- 以下划线开头的标识符有特殊意义,一般应避免使用类似的标识符
- 允许使用中文作为标识符,但不建议使用
标识符的命名规范:
- 模块名尽量短小,并且全部使用小写字母,可以使用下划线分割多个单词。例如:game_main
- 包名尽量短小,并且全部使用小写字母,不推荐使用下划线。例如:com.sykj,不推荐使用com_sykj
- 类名采用单词首字母大写形式。例如:MyClass
- 模块内部的类采用"_" + 大驼峰命名规则的类名组成。例如:在MyClass中的内部类_InnerMyClass
- 函数,类名的属性和方法的命名,全部使用小写字母,多个单词之间使用下划线分隔
- 常量命名时采用全部大写字母,可以使用下划线
- 使用单下划线"_"开头的模块变量或者函数是受保护的,在使用"from xxx import *"语句从模块中导入时,这些模块变量或者函数不能被导入
- 使用双下划线"__"开头的实例变量或者方法是类私有的
- 以双下划线开头和结尾的是Python的专用标识。例如__init__()表示初始化函数
变量
语法结构:
# 变量名 = value
num = 12
- Python是一种动态类型的语言,变量的类型可以随时变化(使用内置函数type()可以查看变量的数据类型)
- 允许多个变量指向同一个值(使用内置函数id()可以返回变量所指的内存地址)
变量命名应遵循以下的几条规则:
- 变量名必须是一个有效的标识符
- 变量名不能使用Python中的保留字
- 慎用小写字母l和大写字母O(看起来像1和0)
- 应选择有意义的单词作为变量名(见名知意)
常量:
- 常量就是在程序运行过程中值不能改变的量
- Python中没有定义常量的保留字
- 常量规定使用大写字母和下划线组成
- 常量首次赋值后,还是可以被其他代码修改的
数据类型
Python中的数据类型分类:
说明:
- 布尔型(bool)
真 True 非0数 --非零即真
假 False 0 - 复数型(complex)
主要用于科学计算。例如:平面场问题,波动问题,电感电容问题
非数字型变量的特点:
- 都是一个序列(sequence),也可以理解为容器
- 取值 []
- 遍历 for in
- 计算长度,最大/最小值,比较,删除
- 连接 + 和重复 *
- 切片
数字型
整数类型
- 表示整数数值,即没有小数部分的数值
- 正整数,负数和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 元组名
元组的元素遍历
与列表的遍历方式相同
元组生成式
语法格式:
注意:
- 元组生成式的结果是一个生成器对象,需要转换成元组或者列表才能查看到元素的内容
- 生成器遍历后,再想重新遍历必须新创建一个生成器对象,因为遍历后原来的生成器对象已经不存在了
# 生成指定范围的数值列表
# 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其他语法后期再出一篇,敬请期待