目录
Python版本
标识符
字母、下划线和数字组成,第一个字符必须是字母或下划线,对大小写敏感
保留字
保留字即关键字,不能用作标识符名称。下面的keyword 模块,可以输出当前版本的所有关键字。
>>> import keyword
>>> keyword.kwlist
注释
单行注释以 # 开头,多行注释可用 # 或 ' ' ' 或 " " " ,嵌套多行注释会导致语法错误,单行注释嵌套在多行注释中是合法的。
# 单行注释
'''
多行注释
多行注释
'''
"""
多行注释
多行注释
"""
缩进
使用缩进来表示代码块,缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。
if True:
print ("True")
else:
print ("False")
多行语句
语句很长,可以使用反斜杠 \ 来实现多行语句。在 [], {}, 或 () 中的多行语句,不需要用反斜杠 \ 。
total = item_one + \
item_two + \
item_three
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
同一行显示多条语句
在同一行中使用多条语句,语句之间使用分号 ; 分割。
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
import 与 from...import
Python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入,格式为: import somemodule
将某个模块中导入某个函数,格式为: from somemodule import somefunction
从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入,格式为: from somemodule import *
变量
Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。等号(=)用来给变量赋值,等号左边是一个变量名,等号右边是存储在变量中的值。
number = 100 # 整型变量
longth = 1000.0 # 浮点型变量
name = "Linda" # 字符串
Python允许同时为多个变量赋值,也可以为多个对象指定多个变量。
a = b = c = 1 #创建一个整型对象,从后向前赋值1,三个变量被赋予相同的数值
a, b, c = 1, 2, "hi" #两个整型对象1和2分配给变量a和b,字符串对象"hi"分配给变量c。
数据类型
Python3 中常见的数据类型:
Number(数字)、String(字符串)、Bool(布尔类型)、List(列表)、Tuple(元组)、Set(集合)、Dictionary(字典)
不可变:Number(数字)、String(字符串)、Tuple(元组)
可变:List(列表)、Dictionary(字典)、Set(集合)
Number(数字)
数字类型
整数(int) :通常被称为整型,是正或负整数,不带小数点。只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
可用多种进制表示整数:十进制、二进制(0b或0B开头,由0和1组成)、八进制(以0o或0O开头,由 0~7 组成)、十六进制(以0x或0X开头,由 0~9 和 A~F(或 a~f)组成)
浮点数(float) :浮点数也就是小数,如1.23,3.14,-9.01等,小数的指数形式 aEn 或 aen (a×10n) a表示尾数部分,十进制数;n是指数部分,十进制整数;E或e是固定的字符,用于分割尾数部分和指数部分;如:2.1E5 = 2.1×105、3.7E-2 = 3.7×10-2 等。
复数(complex) :复数由实部和虚部组成,形式为 a + bj,其中 a 是实部,b 是虚部,j 表示虚数单位。如 1 + 2j、 1.1 + 2.2j 等。
数值运算
在混合计算时,Python会把整型转换成为浮点数。
>>> 5 + 4 # 加法
>>> 9
>>> 4.3 - 2 # 减法
>>> 2.3
>>> 3 * 7 # 乘法
>>> 21
>>> 2 / 4 # 除法,得到一个浮点数
>>> 0.5
>>> 2 // 4 # 除法,得到一个整数
>>> 0
>>> 17 % 3 # 取余
>>> 2
>>> 2 ** 5 # 乘方
>>> 32
String(字符串)
单引号和双引号使用完全相同,使用三引号( ''' 或 """ )可以指定一个多行字符串。
Python没有单独的字符类型,一个字符就是长度为 1 的字符串。字符串不能改变,可以用 + 运算符连接在一起,用 * 运算符重复,会按字面意义级联字符串。反斜杠可以用来转义,使用 r 可以让反斜杠不发生转义。
>>> '字符串1'+'字符串2'
>>> '字符串1字符串2'
>>> 'hi'*3
>>> 'hihihi'
>>> "this " "is " "string"
>>> "this is string"
>>> r"this is a line with \n"
>>> "this is a line with \n"
字符串切片 str[start:end:step],其中 start(包含)是切片开始的索引,end(不包含)是切片结束的索引,step是步长参数。字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。
>>> str='123456'
>>> print(str[0:5:2]) # 输出从第一个开始到最后一个且每隔一个的字符(步长为2)
>>> 135
>>> print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
>>> 12345
>>> print(str[0]) # 输出字符串第一个字符
>>> 1
>>> print(str[2:]) # 输出从第三个开始后的所有字符
>>> 3456
>>> print(str[:-4]) # 输出从倒数第四个开始前面的所有字符
>>> 12
bool(布尔类型)
布尔类型只有两个值:True 和 False,True 和 False 都是关键字
Python3 中,bool 是 int 的子类,布尔值可以被看作整数来使用,True等价于1、False等价于0 ;布尔类型可以和其他数据类型进行比较,在比较时,Python 会将 True 视为 1,False 视为 0; 布尔类型也可以被转换成其他数据类型,比如整数、浮点数和字符串。在转换时,True 会被转换成 1,False 会被转换成 0。
>>> True+1
2
>>> False+1
1
>>> True<2
True
>>> False>-1
True
可以使用 bool()
函数将其他类型的值转换为布尔值。以下值在转换为布尔值时为 False
:None
、False
、零 (0
、0.0
、0j
)、空序列(如 ''
、()
、[]
)和空映射(如 {}
)。其他所有值转换为布尔值时均为 True
。
print(bool(0)) # False
print(bool('')) # False
print(bool([])) # False
print(bool(42)) # True
print(bool('Python')) # True
print(bool([1, 2, 3])) # True
布尔类型可以和逻辑运算符一起使用,包括 and、or 和 not。
print(True and False) # False
print(True or False) # True
print(not True) # False
布尔类型可以用来控制程序的流程,比如判断某个条件是否成立,或者在某个条件满足时执行某段代码。
if True:
print("This will always print")
List(列表)
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同,它支持数字、字符串甚至可以包含列表(嵌套)。
和字符串一样,列表同样可以被索引和截取,加号+进行列表连接,星号*进行重复操作,与字符串不一样的是,列表中的元素是可以改变的。
>>> a = [1, 2, 3, 'hi', [5, 6]]
>>> print(a[1])
>>> 2
>>> print(a[2:])
>>> [3, 'hi', [5, 6]]
>>> b = [7, 'hello']
>>> print(a + b)
>>> [1, 2, 3, 'hi', [5, 6], 7, 'hello']
>>> print(b * 2)
>>> [7, 'hello', 7, 'hello']
>>> a[1] = 'linda'
>>> print(a)
>>> [1, 'linda', 3, 'hi', [5, 6]]
Tuple(元组)
元组与列表相似,元组中的元素类型也可以不相同,但元组写在小括号 () 里,元素之间用逗号隔开,且元组的元素不能修改(虽然tuple的元素不可改变,但它可以包含可变的对象,如list列表)。和字符串一样,元组同样可以被索引和截取,加号+进行元组连接,星号*进行重复操作。
>>> tup1 = (1, 2, 'hi', [3,4])
>>> print(tup1[0])
>>> 1
>>> print(tup1[2:])
>>> ('hi', [3,4])
>>> tup2 = (1, 2)
>>> print(tup1 + tup2)
>>> (1, 2, 'hi', [3,4], 1, 2)
>>> print(tup2 * 2)
>>> (1, 2, 1, 2)
构造包含 0 个或 1 个元素的元组比较特殊,如果没有逗号,Python会将括号解释为数学运算中的括号,而不是元组的表示。
tup1 = () # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号
tup3 = (6) # tup3将是整数类型而不是元组类型
注:string、list 和 tuple 都属于 sequence(序列)。
Set(集合)
Set(集合)是一种无序、可变的数据类型,用于存储唯一的元素;集合中的元素不会重复,并且可以进行交集、并集、差集等常见的集合操作;集合使用大括号 {} 表示,元素之间用逗号 , 分隔。也可以使用 set() 函数创建集合。
>>> sites = {'Google', 'Baidu', 'Facebook'}
>>> print(sites)
>>> {'Google', 'Baidu', 'Facebook'}
>>> a = set('abracadabra')
>>> print(a) # 输出集合,重复的元素被自动去掉
>>> {'a','b','r','c','d'}
>>> b = set('alczm')
>>> print(a - b) # a 和 b 的差集
>>> {'r', 'b', 'd'}
>>> print(a | b) # a 和 b 的并集
>>> {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
>>> print(a & b) # a 和 b 的交集
>>> {'c', 'a'}
>>> print(a ^ b) # a 和 b 中不同时存在的元素
>>> {'z', 'b', 'm', 'r', 'l', 'd'}
Dictionary(字典)
字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合,键(key)必须使用不可变类型,在同一个字典中,键(key)必须是唯一的。字典当中的元素是通过键来存取的,而不是通过偏移存取。
>>> tinydict = {}
>>> tinydict['name'] = 'Joe'
>>> tinydict['age'] = 18
>>> print(tinydict)
>>> {'name': 'Joe', 'age': 18}
>>> tinydict2 = {'name': 'Zhangsan', 'age': 19}
>>> print(tinydict2['age']) # 输出键为 'age' 的值
>>> 19
>>> print (tinydict.keys()) # 输出所有键
>>> dict_keys(['name', 'age'])
>>> print (tinydict2.values()) # 输出所有值
>>> dict_values(['Zhangsan', 19])
构造函数 dict() 可以直接从键值对序列中构建字典,也可以使用字典推导式构建字典。
>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
>>> {'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> dict(Runoob=1, Google=2, Taobao=3)
>>> {'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
>>> {2: 4, 4: 16, 6: 36}
查询变量所指的对象类型
内置的 type() 函数可以用来查询变量所指的对象类型,可以用 isinstance 来判断。
>>> a, b, c, d, e, list = 20, 5.5, True, 4+3j, Ture, ['sdf',234]
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'> <class 'bool'> <class 'list'>
>>> num = 1000
>>> isinstance(num, int)
>>> True
isinstance 和 type 的区别在于:type()不会认为子类是一种父类类型;sinstance()会认为子类是一种父类类型。
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> isinstance(B(), A)
True
>>> type(B()) == A
False
数据类型转换
数据类型转换可以分为两种:
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
隐式类型转换
Python 会自动将一种数据类型转换为另一种数据类型,不需要我们去干预。如下例,Python 会将较小的数据类型(整型)转换为较大的数据类型(浮点型),以避免数据丢失。
>>> num_int = 123
>>> num_flo = 1.23
>>> num_new = num_int + num_flo
>>> print("num_int 数据类型为:",type(num_int))
>>> num_int 数据类型为: <class 'int'>
>>> print("num_flo 数据类型为:",type(num_flo))
>>> num_flo 数据类型为: <class 'float'>
>>> print("num_new 值为:",num_new,",num_new 数据类型为:",type(num_new))
>>> num_new 值为: 124.23 ,num_new 数据类型为: <class 'float'>
显式类型转换
用户将对象的数据类型转换为所需的数据类型,如使用 int()、float()、str() 等预定义函数来执行显式类型转换。
>>> a = int(2.8) # int()强制转换为整型, a输出结果为2
>>> b = float("3") # float()强制转换为浮点型, b输出结果为3.0
>>> c = str(6) # str()强制转换为字符串类型, c输出结果为'6'
>>> num_int = 123
>>> num_str = "456"
>>> num_str = int(num_str) # 强制转换为整型
>>> num_sum = num_int + num_str
>>> print("num_sum 值为:",num_sum,",num_sum 数据类型为:",type(num_sum))
>>> num_sum 值为: 579 ,num_sum 数据类型为: <class 'int'>
以下几个内置的函数可以执行数据类型之间的转换,这些函数返回一个新的对象,表示转换的值。
运算符
算术运算符
+ 加、- 减、* 乘、 / 除、 %取模、 **幂、 //整除(得到整数)
比较运算符
==等于、 !=不等于、 >大于、 <小于、 >=大于等于、 <=小于等于
赋值运算符
=简单赋值、 +=加法赋值(b += a 等价于 b = b + a)、-=减法赋值、 *=乘法赋值、 /=除法赋值、 %=取模赋值、 **=幂赋值、//=取整赋值、:=海象运算符(Python3.8新增)
# 传统写法
n = 10
if n > 5:
print(n)
# 使用海象运算符,作用简化循环条件或表达式中的重复计算
if (n := 10) > 5:
print(n)
位运算符
位运算符是把数字看作二进制来进行计算
&按位与运算符(两者同为1,则结果为1,否则为0)、 | 按位或(有一个为1,则结果为1)、^ 按位异或(两者相异,则结果为1)、 ~按位取反(1变0,0变1)、 <<左移运算符(由"<<"右边的数指定移动的位数,高位丢弃,低位补0)、 >>右移运算符(低位丢弃,高位补0)
a = 0011 1100 # a为60,a换成二进制
b = 0000 1101 # b为13,b换成二进制
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
a = 0011 1100
~a = 1100 0011
a<<2 = 1111 0000
a>>2 = 0000 1111
逻辑运算符
and 布尔“与” or 布尔“或” not 布尔“非”
python中逻辑运算符and,or的用法以及运算的核心思想——“短路逻辑”超详细讲解
只运算bool类型
a and b (当a和b都为真时,结果才为真,否则为假)
a or b (当a和b有一个为真,结果就为真,否则为假)
not a (当a为真,结果为假,反之结果为真)
>>> a = 1>2 and 1<2 #and的左边为False,右边为True
>>> print(a)
>>> False
>>> b = 1>2 or 1<2 #or的左边为False,右边为True
>>> print(b)
>>> True
运算其它类型
a and b (若 a 为 False,表达式返回 a 的值,否则返回 b 的值)
a or b (若 a 为 True,表达式返回 a 的值,否则返回 b 的值)
与运算中,一个为假,整个运算都为假;a and b,如果a已经为假了,不管b的真假,结果都为假,所以直接返回a的值;如果a为真,不确定b的真假,要继续运算,所以返回b的值。
或运算,只要一个为真,整个运算都为真;a or b,只要a是真,结果就为真,所以直接返回a的值;反之,返回b的值。
在python中:None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False,还有自定义类型,如果实现了 __ nonzero __ () 或 __ len __ () 方法且方法返回 0 或False,则其实例也被当作False,其他对象均为True。
a = 1
b = 0
c = "Hello World"
d = ""
print(a and b) #输出结果为 0
print(a or b) #输出结果为 1
print(c and d) #输出结果为 "" /(即什么都不输出)
print(c or d) #输出结果为 Hello World
print(a and c) #输出结果为 Hello World
短路逻辑
若and左侧为false,则短路之后所有的and表达式,直到出现or,则返回and左侧表达式的值继续与or的右侧参与运算。
若or左侧为true,则短路之后所有的表达式,不管是or还是and,直接输出or左侧表达式的值。
若 or 的左侧为 False ,或者 and 的左侧为 True 则不能使用短路逻辑。
>>> result1 = 0 and 100 and 200 and 300 and 400
>>> print(result1)
>>> 0
>>> result2 = 10 or 0 or "" or {} or ()
>>> print(result2)
>>> 10
>>> result3 = 10 or 0 and 20 and 30
>>> print(result3)
>>> 10
>>> result4 = 10 and 0 or {} and 30
>>> print(result4)
>>> {}
成员运算符
in 如果在指定的序列中找到值返回 True,否则返回 False。
not in 如果在指定的序列中没有找到值返回 True,否则返回 False。
>>> a = 1
>>> b = [1,2,3]
>>> print(a in b)
>>> True
>>> print(6 not in b)
>>> True
身份运算符
is 判断两个标识符是不是引用自一个对象
is not 判断两个标识符是不是引用自不同对象
>>> c = 10
>>> d = 10
>>> e = 20
>>> print(c is d)
>>> True
>>> print(id(c) == id(d)) #id() 函数用于获取对象内存地址
>>> True
>>> print(c is not e)
>>> True
注意:is 用于判断两个变量引用对象是否为同一个,==用于判断引用变量的值是否相等。
参考: