基本语法
1.在Python中严格区分大小写
2.Python中的每一行就是一条语句，每条语句以换行结束
3.Python中每一行语句不要过长（规范中建议每行不要超过80个字符）
"rulers":[80],
4.一条语句可以分多行编写，多行编写时语句后边以\结尾
5.Python是缩进严格的语言，所以在Python中不要随便写缩进
6.在Python中使用#来表示注释，#后的内容都属于注释，注释的内容将会被解释器所忽略
我们可以通过注释来对程序进行解释说明，一定要养成良好的编写注释的习惯
注释要求简单明了，一般习惯上#后边会跟着一个空格
1. 数值
10进制的数字不能以0开头
整型(int)
布尔值 (True False)
浮点型(float)
复数
2. 字符串
相同的引号之间不能嵌套，不能跨行
2.1 长字符串
使用三重引号来表示一个长字符串，三重引号可换行，并会保留字符串中的格式
s = '''锄禾日当午，
汗滴禾下土'''
2.2 转义字符
2.3 拼接字符串
字符串只能和字符串拼接，不能和其他类型的进行拼接，否则会报错
2.4 在创建字符串时，可在字符串中指定占位符
%s 在字符串中表示任意字符
%f 浮点数占位符
%d 整数占位符
b = 'hello %s' % '孙悟空' # hello world
b = 'hello %s,hi %s' % ('tom','Kitty') # hello tom,hi kitty
b = 'hello %3.5s' % 'abcdefg' %3s字符串的长度限制在3-5之间 hello abcde
b = 'hello %.2f' % 123.456 # hello 123.46
b = 'hello %d' % 123.95 # 123
2.5 格式化字符串，通过在字符串前添加一个f来创建格式化字符串。在格式化字符串中可以直接嵌入变量
c = 12
d = f'abc {c}' # abc 12
2.6 多个参数
name = '孙悟空'
print('欢迎',name,'光临！') # 欢迎孙悟空光临！
2.7 字符串的复制(将字符串和数字相乘)：解释器会将字符串重复指定的次数并返回
a = a * 20
2.8 空值 (None)
2.9 类型检查
type()用来检查值的类型,并将检查的结果作为返回值返回，可通过变量来接收函数的返回值
print( type(1) ) # <class 'int'>
print( type(1.5) ) # <class 'float'>
print( type(True) ) # <class 'bool'>
print( type('hello') ) # <class 'str'>
print( type(None) ) # <class 'NoneType'>
3. 对象 object
3.1 对象的结构
- 每个对象中都要保存三种数据
- id（标识）
> id用来标识对象的唯一性，每一个对象都有唯一的id
> 对象的id就相当于人的身份证号一样
> 可以通过id()函数来查看对象的id
> id是由解析器生成的，在CPython中，id就是对象的内存地址
> 对象一旦创建，则它的id永远不能再改变
- type（类型）
> 类型用来标识当前对象所属的类型
> 比如：int str float bool 。。。
> 类型决定了对象有哪些功能
> 通过type()函数来查看对象的类型
> Python是一门强类型的语言，对象一旦创建类型便不能修改
- value（值）
> 值就是对象中存储的具体的数据
> 对于有些对象值是可以改变的
> 对象分成两大类，可变对象 不可变对象
可变对象的值可以改变
不可变对象的值不能改变 # int str bool None
student={
'name':'jack',
'age':18,
'height':170
}
3.2 类型转换
- 所谓的类型转换，将一个类型的对象转换为其他对象
- 类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新对象
类型转换的四个函数：
int() 将其他的对象转换为整型，但不会对原来的变量产生影响
1.布尔值：True -> 1 ; False -> 0
2.浮点数：直接取整，省略小数点后的内容
3.字符串：合法的整数字符串，直接转换为对应的数字；如果不是合法的整数字符串，则报错；
4.对于其他不可转换为整型的对象(None)等，则报错；
float() 将其他的对象转换为浮点数，但不会对原来的变量产生影响
1.布尔值：True -> 1.0 ; False -> 0.0
2.整数：转化成浮点数；
3.字符串：合法的浮点数字符串，直接转换为对应的数字；如果不是合法的浮点数字符串，则报错；
4.对于其他不可转换为整型的对象(None)等，则报错；
str() 将其他的对象转换为字符串，但不会对原来的变量产生影响;
1.True -> 'True' ; False -> 'False'
2.123 -> '123'
repr() 将其他的对象转换为表达式字符串，但不会对原来的变量产生影响;
1.对于所有表示空性的对象(0,None,'')都会转换为False,其余的转换为True
3.3 可变对象
- 每个对象中都保存了三个数据：
id（标识）
type（类型）
value（值）
- 列表就是一个可变对象
a = [1,2,3]
- a[0] = 10 （改对象）
- 这个操作是在通过变量去修改对象的值
- 这种操作不会改变变量所指向的对象
- 当我们去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现
- a = [4,5,6] （改变量）
- 这个操作是在给变量重新赋值
- 这种操作会改变变量所指向的对象
- 为一个变量重新赋值时，不会影响其他的变量
- 一般只有在为变量赋值时才是修改变量，其余的都是修改对象
== != 比较对象的值是否相等
is is not 比较对象的id是否相等(更加严格)
4. 运算操作符
- 运算符可以对一个值或多个值进行运算或各种操作
- 比如 + 、-、= 都属于运算符
- 运算符的分类：
1.算术运算符(+ - * /等)
+:两个字符串之间进行加法运算，进行拼串操作；
*：字符串和数字相乘，则对字符串进行复制操作，将字符串重复指定的次数；
/:运算时结果总会返回一个浮点类型；
//:整除，只会保留计算后的整数位，总会返回整型；
**:幂运算，求一个值的几次幂；
%:取模，求两个数相除的余数;
2.赋值运算符(= += %= //= %=等)
3.比较运算符（> >= <= == !=等）：比较两个值之间的关系，返回一个布尔值
在python中可对两个字符串进行大于（等于）或小于（等于）的运算，实际上比较的是字符串的Unicode编码，并且是逐位比较的；（如果不希望比较两个字符串的Unicode编码，则需要将其转换为数字然后再比较）
4.逻辑运算符
not 非 (一元)
a = True b = not a print(b) #False
a = 1 a = not a print(a) #False
and 与 (二元)：只有在符号两侧的值都为True时，才会返回True,只要有一个False就返回False;
Python中的与运算是短路的与，如果第一个值为False,则不再看第二个值
or 或 (二元)：Python中的或运算是短路的或，如果第一个值为True,则不再看第二个值
result = True or False print(result) #True
非布尔值的与或运算
当对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终返回原值
1 and 2 #2 1 or 2 #1
1 and 0 #0 1 and 0 #1
0 and None #0 0 and None #None
补充：逻辑运算符可以连着使用； 1 < 2 < 3 #相当于1 < 2 and 2 < 3
5.条件运算符（三元运算符）
语句1 if 条件表达式 else 语句2
5. 列表
- 列表是Python中的一个对象
- 对象（object）就是内存中专门用来存储数据的一块区域
- 之前我们学习的对象，像数值，它只能保存一个单一的数据
- 列表中可以保存多个有序的数据
- 列表是用来存储对象的对象
- 列表的使用：
1.列表的创建
2.操作列表中的数据
列表中存储的数据，称为元素
一个列表中可存储多个元素，也可在创建列表时，来指定列表中的元素
列表中可保存任意的对象
# myList = [10,'hello',[1,2],True,None,print]
通过索引获取列表中的元素，语法：myList[索引]
列表中的索引可以是负数，-1表示倒数第一个，-2表示倒数第二个
print(myList[-1]) # <built-in function print>
len(),该函数可获取列表的长度
print(len(myList)) # 6
切片：从现有列表中，获取一个子列表
语法：列表[起始:结束]
1.通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
2.做切片操作时，总会返回一个新的列表，不影响原来的列表
3.如果省略起始位置，则会从第一个元素开始截取
4.如果省略结束位置，则会一直截取到最后
5.如果起始位置和结束位置都省略，相当于创建了一个列表的副本
语法：列表[起始:结束:步长]
1.步长：每次获取元素的间隔，默认值是1
2.步长不能是0，但可为负数（从列表后部向前边取元素）
num = [1,2,3,4,5,6,5,6]
num[1:4:2] #[2,4]
num[::3] #[1,4]
num[::-1] #[6,5,6,5,4,3,2,1]
+ 可将两个列表拼接为一个列表
* 可将列表重复指定的次数
in 用来检查指定元素是否存在于列表中，如果存在 返回True,否则返回False
print(5 in num) #True
not in 用来检查指定元素是否存在于列表中，如果存在 返回False,否则返回True
min() 获取列表中的最小值 print(min(num)) #1
max() 获取列表中的最大值
方法一:必须通过 对象.方法() 的形式调用
index() 获取指定元素在列表中的第一次出现时的索引，若没有该元素则报错
index()的第二个参数，表示查找的起始位置，第三个参数，表示查找的结束位置
num.index(2) #1
count() 统计指定元素在列表中出现的次数
num.count(5) #2
修改列表
newList = ['hi',5,10,'haha','2']
1.通过索引修改元素
newLsit[0] = 'hello'
2.通过del删除元素
del newList[2]
3.通过切片修改列表，在给切片赋值时，只能使用序列
newList[0:2] = [1,2,3] print(newList) #[1,2,3,10,'haha','2']
向索引为0的位置插入元素
newList[0:0] = ['你好'] print(newList) #['你好','hi',5,10,'haha','2']
当设置步长时，序列中元素的个数必须和切片中元素的个数一致
newList[::2] = [8,8,8] print(newList) #[8,5,8,'haha',8]
4.通过切片删除元素
del newList[0:2]
del newList[::2]
newList[0:2] = []
方法二：
num1 = [1,2,3,4,5]
num2 = [-1,1,5,2,1]
1.append() 向列表的最后添加一个元素
num1.append(6) #[1,2,3,4,5,6]
2.insert() 向列表的指定位置插入一个元素
num1.insert(2,6) #[1,2,6,3,4,5]
3.extend() 使用新的序列来扩展当前序列。需要一个序列作为参数，将该序列中的元素添加到当前列表中。
num1.extend([6,7,8]) #[1,2,3,4,5,6,7,8]
4.clear() 清空序列
num1.clear() #[]
5.pop() 根据索引删除被返回被删除的元素
num1.pop(2) #3 num1 = [1,2,4,5]
num1.pop() 删除最后一个元素 #[1,2,3,4]
6.remove() 删除指定值的元素，如果相同值的元素有多个，只会删除第一个，无返回值。
num1.remove(2) #[1,3,4,5]
7.reverse() 反转列表
num1.reverse() #[5,4,3,2,1]
8.sort() 对列表中的元素排序，默认是升序排列
num2.sort() #[-1,1,1,2,5]
降序:num2.sort(reverse = True) #[5,2,1,1,-1]
遍历列表
num2 = [1,2,3,4,5,6,7,8]
1.通过while循环来遍历列表
i = 0
while i < len(num2):
print(num2[i])
i += 1
2.通过for循环来遍历列表
语法： for 变量 in 序列:
代码块
for循环的代码会执行多次，序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变 量，可通过变量来获取列表中的元素。for()循环除了创建方式外，其余的都和while一样，包括else break
continue都可在for循环中使用。
for i in num2:
print(i)
3.range() 用来生成一个自然数的序列，可创建一个指定次数的for循环
三个参数：1.起始位置(可省略，默认为0)
2.结束位置
3.步长(可省略，默认为1)
for i range(20):
print(i)
6. 序列 sequence
- 序列是Python中最基本的一种数据结构
- 数据结构指计算机中数据存储的方式
- 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）
并且序列中的数据会按照添加的顺序来分配索引
- 序列的分类：
可变序列（序列中的元素可以改变）：
> 列表（list）
不可变序列（序列中的元素不能改变）：
> 字符串（str）
> 元组（tuple）
通过list()函数将其他的序列转换为list
a = 'haha' b = list(a) #['h','a','h','a']
7. 元组 tuple
元组是不可变序列（不能尝试为元组中的元素重新赋值），它的操作方式基本上和列表一致.
1.创建元组
当元组不是空元组时，括号可省略。
如果元组不是空元组，它里面至少要有一个,
myTuple = (1,2,3,4)
2.元组的解构，将元组中每一个元素都赋值给一个变量
a,b,c,d = myTuple
2.1 交互a和b的值
a,b = (b,a)
2.2 对元组进行解构时，变量的数量必须和元组中的元素的数量一致，可在变量的前面添加一个*，这个变量将会获取
元组中所有剩余的元素。不能同时出现两个或以上的*变量。
a,b,*c = myTuple # a = 1 b = 2 c = [3,4]
8. 字典 dict
- 字典属于一种新的数据结构，称为映射（mapping）
- 字典的作用和列表类似，都是用来存储对象的容器
- 列表存储数据的性能很好，但是查询数据的性能的很差
- 在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素
- 在查询元素时，字典的效率是非常快的
- 在字典中可以保存多个对象，每个对象都会有一个唯一的名字
这个唯一的名字，我们称其为键（key），通过key可以快速的查询value
这个对象，我们称其为值（value）
所以字典，我们也称为叫做键值对（key-value）结构
每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）
1.创建字典
1.1 使用{}创建字典，语法：{key:value,key:value}
字典的值可以是任意对象
字典的键可以是任意的不可变对象(int str bool tuple等)，但一般使用str
字典的键是不能重复的，如果重复 后面的会替换前边的
a = {
'name':'孙悟空',
'category':'猴子'
}
1.2 使用dict()函数创建字典
每个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
b = dict(name = '猪八戒',age = 20,sex = '男')
1.3 将一个包含有双值子序列的序列转换为字典
双值序列，序列中只有两个值，[1,2] ('a',3) 'ab'
子序列，如果序列中的元素也是序列，称这个元素为子序列 [(1,2),('a','b')]
c = dict([('name','沙僧'),('age',30)])
2.根据键获取值
2.1 语法：d[key] 如果键不存在，会报错
print(a['name']) # 孙悟空
2.2 get(key[,default]) 用来根据键来获取字典中的值，如果获取的键在字典中不存在，则返回None。也可指 定一个默认值，作为第二个参数，这样获取不到值时 将返回默认值
print(a.get('hello','默认值')) # 默认值
3.len() 获取字典中键值对的个数
4.in 检查字典中是否包含指定的键 print('name' in a) #True
not in 检查字典中是否不包含指定的键
5.修改字典
5.1 语法：a[key] = value 如果key存在则覆盖，不存在则添加
a['name'] = '牛魔王' # 修改字典中的key-value
a['address'] = '火焰山' #向字典中添加key-value
5.2 setdefault(key[,default]) 用来向字典中添加key-value
如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
如果key不存在，则向字典中添加这个key，并设置value
result = a.setdefault('hihi','红孩儿')
5.4 update([other]) 将其他字典中的key-value添加到当前字典中。
如果有 重复的key,则后面的会替换掉当前的
a.update(b)
print(a) #{'name': '猪八戒', 'category': '猴子', 'age': 20, 'sex': '男'}
6.删除
6.1 使用 del 删除字典中的 key-value
del a['name'] a = {'category':'猴子'}
6.2 popitem() 随机删除字典里的一个键值对，一般都会删除最后一个键值对
删除之后，会将删除的key-value作为返回值返回，返回的是一个元组，元组中有两个元素，第一个元素是 删除的key,第二个是删除的value。
a.popitem()
6.3 pop(key[,default]) 根据key删除字典中的key-value，将被删除的value返回。
如果删除不存在的key，会抛出异常。如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回 默认值。
a.pop('name')
a.pop('hh','这是默认值')
6.4 clear() 用来清空字典
d.clear()
7. copy() 该方法用于对字典进行浅复制
复制以后的对象，和原对象是独立，修改一个不会影响另一个
注意：浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
a.copy()
8.遍历字典
d = {'name':'孙悟空','age':18,'sex':'男'}
8.1 keys() 返回字典里的所有的key。该方法会返回一个序列，序列中保存有字典的所有的键。
通过遍历keys()获取所有键
for k in d.keys():
print(k,d[k])
8.2 values() 返回一个序列，序列中保存有字典的左右的值
8.3 items() 返回字典中所有项。
它会返回一个序列，序列中包含有双值子序列。双值分别是：字典中的key和value
for k,v in d.items():
print(k,'=',v) # name = 孙悟空 age = 18 sex = 男
9. 集合 set
- 集合和列表非常相似
- 不同点：
1.集合中只能存储不可变对象
2.集合中存储的对象是无序（不是按照元素的插入顺序保存）
3.集合中不能出现重复的元素
1.创建
1.1 使用{}创建集合
s = {1,2,6,4,7}
1.2 使用 set() 函数创建集合
创建空集合 s = set()
1.3 通过set()将序列和字典转换为集合
s = set([1,2,3,4,1,1,2]) # {1,2,3,4}
s = set('hello') # {'h','o','l','e'}
# 使用set()将字典转化为集合时，只会包含字典中的键
s = set({'a':1,'b':2,'c':3}) # {c,a,b}
2.使用 in 和 not in 检查集合中的元素
3.使用 len() 获取集合中元素的数量
4. add() 向集合中添加元素 s.add(10)
5. update() 将一个集合中的元素添加到当前集合中，可传递序列或字典作为参数，字典只会使用键
s2 = set('hello')
s.update(s2) # {'h', 1, 2, 'o', 4, 'e', 6, 7, 'l'}
6.删除
6.1 pop() 随机删除并返回一个集合中的元素
6.2 remove() 删除集合中的指定元素 s.remove(2)
6.3 clear() 清空集合
7.copy()对集合进行浅复制
8.集合运算：在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
s1 = {1,2,3,4,5} s2 = {3,4,5,6,7,8}
8.1 & 交集运算
result = s1 & s2 # {3,4,5}
8.2 | 并集运算
result = s1 | s2 # {1,2,3,4,5,6,7,8}
8.3 - 差集
result = s1 - s2 # {1,2}
8.4 ^ 异或集
result = s1 ^ s2 # {1,2,6,7,8,9}
8.5 <= 检查一个集合是否为另一个集合的子集
result = s1 <= s2 # False
result = {1,2,3} <= {1,2,3} # True
8.6 < 检查一个集合是否为另一个集合的真子集
result = {1,2,3} < {1,2,3} # False
8.7 >= 检查一个集合是否为另一个的超集
8.8 > 检查一个集合是否为另一个的真超集
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/141467.html
