开始可以借鉴阿里腾讯开发规范——实际中运用会大体相近
1、注释
#:单行注释
‘’‘ ’‘’ 或者“”“ ”“”:多行注释
2、标识符
合法:
ABC、ABC_123、姓名、_123
不合法:
123、1ABC、if(保留字)、init(预定义标识符)
(1)当标识符用作模块名时,应尽量短小,并且全部使用小写字母,可以使用下划线分割多个字母,例如game_main、game_register等。 (2)当标识符用作包的名称时,应尽量短小,并且全部使用小写字母,不推荐使用下划线,例如com.mr、com.mr.book等。 (3)当标识符用作类名时,应采用单词首字母大写的形式。例如,定义一个图书类,可以命名为Book。 (4)模块内部的类名,可以采用“下划线+首字母大写”的形式,如_Book。 函数名、类中的属性名和方法名,应全部使用小写字母,多个单词之间可以用下划线分割。 (5)常量命名应全部使用大写字母,单词之间可以用下划线分割。
-
字符集和格式:
-
标识符可以包含字母(大小写敏感)、数字和下划线 。
_
-
标识符的第一个字符必须是字母(大写或小写)或下划线 。
_
-
-
关键字和保留字:
-
不能使用Python中的关键字和保留字作为标识符。这些包括 , , , , , 等。
if``else``for``while``class``def
-
-
大小写敏感:
-
Python是大小写敏感的,因此标识符的大小写会被区分。
-
-
命名约定:
-
Python通常推荐以下划线命名法(Snake Case)来命名变量、函数、方法和模块名。这意味着多个单词用下划线连接,例如 , 。
my_variable``calculate_area()
-
-
类命名约定:
-
类名通常使用首字母大写的驼峰命名法(Pascal Case),例如 , 。
MyClass``MyClassWithMethods
-
-
变量和函数名:
-
变量名和函数名应该具有描述性,能够清晰地表达其用途或含义。
-
例如
max_value`
,calculate_area()
,`is_valid()
, 等。
-
-
常量命名:
-
Python中没有真正意义上的常量,但是约定上,常量通常使用全大写字母,用下划线分隔单词。例如,
MAX_SIZE`,`PI`,`DEFAULT_VALUE.
-
input函数:
实现用户的输入
eval函数:
以python表达式的方式解析并执行字符串
print函数:
默认是换行的
print('123') 换行
print('123' ,end=" ") 不换行
3、数值类型
基本的数值类型:int、float、string、complex(复数类型:见的少 3+5j )
空值:None,常用于没有返回值的函数结果,
bool:值为true 和 flase
bytes:用bytes()函数进行数据转换;这种类型用于网络数据传输、二进制图片和文件的保存
-
Number(数字)
-
String(字符串)
-
bool(布尔类型)
-
List(列表)
-
Tuple(元组)
-
Set(集合)
-
Dictionary(字典)
Python3 的六个标准数据类型中:
-
不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
-
可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。
此外还有一些高级的数据类型,如: 字节数组类型(bytes)。
(1)浮点类型详解
-
十进制形式 这种就是我们平时看到的小数形式,例如 34.6、346.0、0.346。
书写小数时必须包含一个小数点,否则会被 Python 当作整数处理。
2、指数形式 Python 小数的指数形式的写法为:
aEn 或 aen
a 为尾数部分,是一个十进制数;n 为指数部分,是一个十进制整数;E或e是固定的字符,用于分割尾数部分和指数部分。整个表达式等价于 a×10n。
指数形式的小数举例:
2.1E5 = 2.1×105,其中 2.1 是尾数,5 是指数。 3.7E-2 = 3.7×10-2,其中 3.7 是尾数,-2 是指数。 0.5E7 = 0.5×107,其中 0.5 是尾数,7 是指数。
注意,只要写成指数形式就是小数,即使它的最终值看起来像一个整数。例如 14E3 等价于 14000,但 14E3 是一个小数。
Python 只有一种小数类型,就是 float。C语言有两种小数类型,分别是 float 和 double:float 能容纳的小数范围比较小,double 能容纳的小数范围比较大。
【实例】小数在 Python 中的使用:
f1 = 12.5 print("f1Value: ", f1) print("f1Type: ", type(f1)) f2 = 0.34557808421257003 print("f2Value: ", f2) print("f2Type: ", type(f2)) #当数值过小时Python会自动将其转换为科学计数法的形式,以更方便地显示和理解极小的数值。 f3 = 0.0000000000000000000000000847 print("f3Value: ", f3) print("f3Type: ", type(f3)) f4 = 345679745132456787324523453.45006 print("f4Value: ", f4) print("f4Type: ", type(f4)) f5 = 12e4 print("f5Value: ", f5) print("f5Type: ", type(f5)) f6 = 12.3 * 0.1 print("f6Value: ", f6) print("f6Type: ", type(f6))
4、字符串的索引和切片
这个不多说看菜鸟教程,一看就会
'+'在字符串中有连接作用;
len(s):返回s的长度或其他组合类型的元素个数
# 用法示例 my_list = [1, 2, 3, 4, 5] print(len(my_list)) # 输出: 5 my_string = "Hello, World!" print(len(my_string)) # 输出: 13 my_dict = {'a': 1, 'b': 2, 'c': 3} print(len(my_dict)) # 输出: 3
str(s):把元素(s)转换为字符串
chr(‘65’):返回‘A’;
5、数据类型转换
1、type()
对变量进行类型的判断
自动类型的转换(不同类型混合运算生成的结果为最宽的类型)
type(10/4*4) flaot 123+4.0=127.0
2、isinstance()
跟提供的类型进行对比
isinstance(3,int) true isinstance(3.2,int) flase isinstance(3.2,(int,float,str)) true
6、正则表达式的常用函数
re.complie()使正则表达式变为正则表达式对象——一般使用网上工具
import re strpat = r'(\d+)'(\.\d*)?‘ txt=..... pats=re.complie(strpat)
re.match()扫描提供的对象,查找是否有匹配的
escape()
如果特殊字符太多,需要输入大量反斜杠,可以使用escape()
7、列表、元组、字典
列表(List)
-
有序集合:列表是有序的,可以通过索引访问元素,适合存储顺序相关的数据。
-
可变性:列表是可变的,可以动态增删元素,适合需要频繁修改数据的场景。
-
适用场景:
-
存储同类型或不同类型的数据集合,例如存储一组学生名单、待办事项列表等。
-
需要动态增删元素的情况,例如管理用户的收藏列表、网站的文章列表等。
-
元组(Tuple)
-
不可变性:元组一旦创建后,其内容不可修改,具有保护数据的特性。
-
性能优势:元组比列表更加轻量和高效,适合作为常量集合使用。
-
适用场景:
-
存储不会改变的数据集合,例如存储一组坐标、日期时间信息等。
-
作为函数返回值,可以确保数据不被修改。
-
在多线程环境下作为安全的数据结构使用。
-
字典(Dictionary)
-
键值对:字典存储的是键值对,可以通过键快速查找值,适合需要快速访问和查找数据的场景。
-
动态性:字典是可变的,可以方便地增删键值对,适合动态更新和管理数据。
-
适用场景:
-
存储具有映射关系的数据,例如用户信息、产品属性等。
-
需要快速查找和更新数据的情况,例如建立用户ID到详细信息的映射、存储配置信息等。
-
JSON 格式数据的解析和处理。
-
总结
-
列表适合存储有序的元素集合,需要频繁增删操作的场景。
-
元组适合不可变的、静态数据集合,用于保护数据或作为常量集合使用。
-
字典适合存储键值对,需要快速查找和更新数据的场景。
(1)列表
(1)索引和切片
#!/usr/bin/python3 list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[0] ) print( list[1] ) print( list[2] ) #反向索引 #!/usr/bin/python3 list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[-1] ) print( list[-2] ) print( list[-3] )
(2)切片
#!/usr/bin/python3 nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] print(nums[0:4]) #反向所以截止 #!/usr/bin/python3 list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"] # 读取第二位 print ("list[1]: ", list[1]) # 从第二位开始(包含)截取到倒数第二位(不包含) print ("list[1:-2]: ", list[1:-2])
(3)修改和更新
#!/usr/bin/python3 list = ['Google', 'Runoob', 1997, 2000] print ("第三个元素为 : ", list[2]) list[2] = 2001 print ("更新后的第三个元素为 : ", list[2]) list1 = ['Google', 'Runoob', 'Taobao'] list1.append('Baidu') print ("更新后的列表 : ", list1) #输出 第三个元素为 : 1997 更新后的第三个元素为 : 2001 更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']
(4)删除(del)
#!/usr/bin/python3 list = ['Google', 'Runoob', 1997, 2000] print ("原始列表 : ", list) del list[2] print ("删除第三个元素 : ", list) #输出 原始列表 : ['Google', 'Runoob', 1997, 2000] 删除第三个元素 : ['Google', 'Runoob', 2000]
(5)拼接和比较
>>> squares = [1, 4, 9, 16, 25] >>> squares += [36, 49, 64, 81, 100] >>> squares [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>> #嵌套 >>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b' #比较 # 导入 operator 模块 import operator a = [1, 2] b = [2, 3] c = [2, 3] print("operator.eq(a,b): ", operator.eq(a,b)) print("operator.eq(c,b): ", operator.eq(c,b)) #输出 operator.eq(a,b): False operator.eq(c,b): True
(6)列表的函数和方法
函数: len(list) 列表元素个数 max(list) 返回列表元素最大值 min(list) 返回列表元素最小值 list(seq) 将元组转换为列表 方法: list.append(obj) 在列表末尾添加新的对象 这个list就是所设的变量,随条件而变化,基本的写法就是只要写list.append(obj),但obj只添加一个值 list.count(obj) 统计某个元素在列表中出现的次数 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 list.insert(index, obj) 将对象插入列表 list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 list.remove(obj) 移除列表中某个值的第一个匹配项 这个时候想为什么不能删除重复的值,但为什么不用集合能,这个就没想到,要对数据类型更加熟悉 list.reverse() 反向列表中元素q list.sort( key=None, reverse=False) 对原列表进行排序 list.clear() 清空列表 list.copy() 复制列表
(2)元组
元组除了内容不可修改外性质跟列表差不多——以下写的是与列表略微不同的地方
这个括号可有可无,当要写,规范格式
(1)修改
#!/usr/bin/python3 #元组中的元素值是不允许修改的,但我们可以对元组进行连接组合 tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3)
(2)删除
#!/usr/bin/python3 #元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组 tup = ('Google', 'Runoob', 1997, 2000) print (tup) del tup print ("删除后的元组 tup : ") print (tup) #输出 删除后的元组 tup : Traceback (most recent call last): File "test.py", line 8, in <module> print (tup) NameError: name 'tup' is not defined
(3)特性:元组不可变
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b') >>> tup[0] = 'g' # 不支持修改元素 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> id(tup) # 查看内存地址 4440687904 >>> tup = (1,2,3) >>> id(tup) 4441088800 # 内存地址不一样了 #从以上实例可以看出,重新赋值的元组 tup,绑定到新的对象了,不是修改了原来的对象。
(4)函数
函数: len(tuple) 列表元素个数 max(tuple) 返回列表元素最大值 min(tuple) 返回列表元素最小值 tuple(iterable) 将可迭代系列转换为元组
(3)字典
定义:
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中
d = {key1 : value1, key2 : value2, key3 : value3 }
(1)创建空字典
# 使用大括号 {} 来创建空字典 emptyDict = {} # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:", len(emptyDict)) # 查看类型 print(type(emptyDict)) #输出 {} Length: 0 <class 'dict'>
(2)使用内建函数 dict() 创建字典
emptyDict = dict() # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:",len(emptyDict)) # 查看类型 print(type(emptyDict)) #输出 {} Length: 0 <class 'dict'>
(3)索引
#!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} print ("tinydict['Name']: ", tinydict['Name']) print ("tinydict['Age']: ", tinydict['Age']) #输出 tinydict['Name']: Runoob tinydict['Age']: 7 #如果用字典里没有的键访问数据,会输出错误如下 #!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} print ("tinydict['Alice']: ", tinydict['Alice']) #输出 Traceback (most recent call last): File "test.py", line 5, in <module> print ("tinydict['Alice']: ", tinydict['Alice']) KeyError: 'Alice'
(4)修改字典
#!/usr/bin/python3 #向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} tinydict['Age'] = 8 # 更新 Age tinydict['School'] = "菜鸟教程" # 添加信息 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) #输出 tinydict['Age']: 8 tinydict['School']: 菜鸟教程
(5)删除字典
能删单一的元素也能清空字典,清空只需一项操作。
显式删除一个字典用del命令,如下实例
#!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} del tinydict['Name'] # 删除键 'Name' tinydict.clear() # 清空字典 del tinydict # 删除字典 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) #输出 Traceback (most recent call last): File "/runoob-test/test.py", line 9, in <module> print ("tinydict['Age']: ", tinydict['Age']) NameError: name 'tinydict' is not defined
(6)字典的特性
字典值可以是任何的 python 对象,既可以是标准的对象,也可以是用户定义的,但键不行。 两个重要的点需要记住: 1)不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住 #!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'} print ("tinydict['Name']: ", tinydict['Name']) #输出 tinydict['Name']: 小菜鸟 2)键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下实例: #!/usr/bin/python3 tinydict = {['Name']: 'Runoob', 'Age': 7} print ("tinydict['Name']: ", tinydict['Name']) #输出 Traceback (most recent call last): File "test.py", line 3, in <module> tinydict = {['Name']: 'Runoob', 'Age': 7} TypeError: unhashable type: 'list'
(7)函数
len(dict) 计算字典元素个数,即键的总数。 str(dict) 输出字典,可以打印的字符串表示。 type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。
(8)方法
1 dict.clear() 删除字典内所有元素 2 dict.copy() 返回一个字典的浅复制 3 dict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值 4 dict.get(key, default=None) 返回指定键的值,如果键不在字典中返回 default 设置的默认值 5 key in dict 如果键在字典dict里返回true,否则返回false 6 dict.items() 以列表返回一个视图对象 7 dict.keys() 返回一个视图对象 8 dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default 9 dict.update(dict2) 把字典dict2的键/值对更新到dict里 10 dict.values() 返回一个视图对象 11 pop(key[,default]) 删除字典 key(键)所对应的值,返回被删除的值。 12 popitem() 返回并删除字典中的最后一对键和值。
8、集合
定义:集合是一个无序的不重复元素序列
可以使用{}创建集合当不能是空集合,也可以用set()函数创建(创建空集合必须用set()函数)
parame = {value01,value02,...} 或者 set(value) set1 = {1, 2, 3, 4} # 直接使用大括号创建集合 set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合
(1)添加元素
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.add("Facebook") >>> print(thisset) {'Taobao', 'Facebook', 'Google', 'Runoob'} #还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等:update >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.update({1,3}) >>> print(thisset) {1, 3, 'Google', 'Taobao', 'Runoob'} >>> thisset.update([1,4],[5,6]) >>> print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'} >>>
(2)删除
#有两种——s.remove()|s.discard()|pop()-随机删除 >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.remove("Taobao") >>> print(thisset) {'Google', 'Runoob'} >>> thisset.remove("Facebook") # 不存在会发生错误 Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'Facebook' >>> >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.discard("Facebook") # 不存在不会发生错误 >>> print(thisset) {'Taobao', 'Google', 'Runoob'}
方法:
add() 为集合添加元素 clear() 移除集合中的所有元素 copy() 拷贝一个集合 difference() 返回多个集合的差集 difference_update() 移除集合中的元素,该元素在指定的集合也存在。 discard() 删除集合中指定的元素 intersection() 返回集合的交集 intersection_update() 返回集合的交集。 isdisjoint() 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 issubset() 判断指定集合是否为该方法参数集合的子集。 issuperset() 判断该方法的参数集合是否为指定集合的子集 pop() 随机移除元素 remove() 移除指定元素 symmetric_difference() 返回两个集合中不重复的元素集合。 symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 union() 返回两个集合的并集 update() 给集合添加元素 len() 计算集合元素个数
9、推导式
[表达式 for 变量 in 列表] [out_exp_res for out_exp in input_list] 或者 [表达式 for 变量 in 列表 if 条件] [out_exp_res for out_exp in input_list if condition]
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith'] >>> new_names = [name.upper()for name in names if len(name)>3] >>> print(new_names) ['ALICE', 'JERRY', 'WENDY', 'SMITH'] >>> multiples = [i for i in range(30) if i % 3 == 0] >>> print(multiples) [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
(1)字典推导式
{ key_expr: value_expr for value in collection } 或 { key_expr: value_expr for value in collection if condition } listdemo = ['Google','Runoob', 'Taobao'] # 将列表中各字符串值为键,各字符串的长度为值,组成键值对 >>> newdict = {key:len(key) for key in listdemo} >>> newdict {'Google': 6, 'Runoob': 6, 'Taobao': 6} >>> dic = {x: x**2 for x in (2, 4, 6)} >>> dic {2: 4, 4: 16, 6: 36} >>> type(dic) <class 'dict'>
(2)集合推导式
>>> setnew = {i**2 for i in (1,2,3)} >>> setnew {1, 4, 9} >>> a = {x for x in 'abracadabra' if x not in 'abc'} >>> a {'d', 'r'} >>> type(a) <class 'set'>
(3)元组
>>> a = (x for x in range(1,10)) >>> a <generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象 >>> tuple(a) # 使用 tuple() 函数,可以直接将生成器对象转换成元组 (1, 2, 3, 4, 5, 6, 7, 8, 9)
9、迭代器
定义:访问集合元素的一种方式。迭代器是一个可以记住遍历位置的对象。迭代器对象从第一个元素开始访问,直到所有元素被访问。
迭代器有两个基本的方法:iter()和next()
(1)使用iter()或者next() 函数可以将可迭代对象(如列表、字典、字符串等)转换为迭代器
>>> list=[1,2,3,4] >>> it = iter(list) # 创建迭代器对象 >>> print (next(it)) # 输出迭代器的下一个元素 1 >>> print (next(it)) 2 >>> #!/usr/bin/python3 import sys # 引入 sys 模块 list=[1,2,3,4] it = iter(list) # 创建迭代器对象 while True: try: print (next(it)) except StopIteration: sys.exit()
也可以使用常规for语句进行遍历:
#!/usr/bin/python3 list=[1,2,3,4] it = iter(list) # 创建迭代器对象 for x in it: print (x, end=" ")
(2)面向对象时
把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
class MyNumbers: def __iter__(self): self.a = 1 return self def __next__(self): x = self.a self.a += 1 return x myclass = MyNumbers() myiter = iter(myclass) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter))