目录
4.2 [], {}, 或 () 中的多行语句,不需要使用反斜杠 \
1 标识符和关键字
1.1 标识符
用户自定义的、由程序使用的符号。不能是关键字
由字母、数字、下划线组成。开头只能是字母和下划线。如:width height name student
1.2 关键字
python预先定义了一部分具有特殊意义的标识符,用于自身使用,成为关键字或保留字。
python常用关键字: 33个
2 python注释
2.1 为什么需要注释?
对程序设计者是标记作用,为以后能够及时有效地进行维护/修改。
对程序阅读者是解释作用,能让读者了解程序和设计者的思路。
对企业来说,在人员接替时能够保证稳定过渡。
2.2python注释有哪些?
单行注释 #
多行注释 ''' ''' """ """
如下:
# 第一个单行注释
# 第二个单行注释
'''
这是一个用单引号
表示的多行注释
'''
"""
这是一个用双引号
表示的多行注释
"""
print ("Hello, 欢迎你来到Python的世界!") #输出 Hello, 欢迎你来到Python的世界!
输出结果:
3 python 语句的缩进
python最具特色的就是使用缩进来表示代码块,不需要使用大括号 {} 。
缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。
如下:
a = 1
if a == 1:
print("菜鸟小陈是大菜鸟!")
else:
print("菜鸟小陈不是菜鸟,是大佬呀!")
输出结果:
以下代码最后一行缩进数的空格数不一致,会导致运行结果出错
a = 1
if a == 1:
print("菜鸟小陈是大菜鸟!")
else:
print("菜鸟小陈不是菜鸟,是大佬呀!")
输出结果:
4 Python 多行语句
4.1 使用反斜杠 \
Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠 \ 来实现多行语句。
#输入数字,计算xiao_chen
xiao_chen = 250 + \
250 + \
20
print("xiao_chen:",xiao_chen)
输出结果:
4.2 [], {}, 或 () 中的多行语句,不需要使用反斜杠 \
#一键三连,编程之路,你我同在!
xiao_chen = ("感谢你阅读到这里,小陈送你一首诗:\n"
"我说 你是人间的四月天;\n"
"笑响点亮了四面风;\n"
"轻灵在春的光艳中交舞着变。\n"
"你是四月早天里的云烟,\n"
"黄昏吹着风的软,星子在\n"
"无意中闪,细雨点洒在花前。\n"
"那轻,那娉婷,你是,\n"
"鲜妍百花的冠冕你戴着,\n"
"你是天真,庄严,\n"
"你是夜夜的月圆。\n"
"雪化后那片鹅黄,你像;\n"
"新鲜初放芽的绿,你是;\n"
"柔嫩喜悦,水光浮动着你梦期待中白莲。\n"
"你是一树一树的花开,\n"
"是燕在梁间呢喃。\n"
"——你是爱,是暖,\n"
"是希望,\n"
"你是人间的四月天!")
print(xiao_chen)
输出结果:
5 输入与输出
想必你是第一次接触编程的话,肯定不知道上面的那些例子中的print() 是什么意思吧!
下面就来介绍输出print()与另一个函数input输入
5.1 为什么需要输入与输出
计算机程序都是用来解决特定的计算问题的,每个程序都有统一的运算模式:输入数据
处理数据和输出数据。
5.2 input() 输入
Python使用input函数接收用户输入:
a = input("请输入你的名字:")
print(a)
结果如下:
5.3 print() 输出
print() 函数如果没有参数,将输出一个空行。
print("我爱你")
print("")
print("你爱我")
print("")
print("蜜雪冰城甜蜜蜜")
输出结果:
6 变量
在编程语言中,用标识符命名的存储单元的地址称为变量,也叫内存变量。变量的赋值,是将值赋给变量,赋值完成后,变量所指向的存储单元储存了被赋的值。
python中赋值操作符有:= += -= *= /= **= //=
变量是内存中命名的存储位置,值可以动态变化。
Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
6.1 单个变量赋值:
a = 123
b = 321
c = "你最帅!你最美!"
d = 5.20
e = "的特效了不得"
print(a)
print(b)
print(c)
print(d,e)
输出结果:
6.2 多个变量赋值
a = b =c = "唉"
d, e, f = "嘚嘚以嘚嘚" ,"造孽啊", "或许月老掉线儿爱由财神来管"
print(a,b,c)
print(d,e,f)
输出结果:
7 数据类型
7.1 为什么需要数据类型?
计算机程序设计的目的是存储和处理数据,将数据分为合理的类型既可以方便处理数据,又可以提高数据的处理效率,节省存储空间。
python中有六个标准的数据类型:
Nmuber(数字) String(字符串) List(列表) Tuple(元组) Set(集合) Dictionary(字典)
python3中六个标准数据类型中:
- 不可变数据:Number(数字)、String(字符串)、 Tuple(元组)
- 可变数据: List(列表)、 Dictionary(字典)、Set(集合)
7.2 Number 数字类型
python3中有4种 数字类型int、float、bool、complex(复数)
7.2.1 int 整型
对应数学中的整数概念,表示方式有
二进制( 0B 0b开头) 八进制(0O 0o开头) 十进制(0到数字9组合) 十六进制(0X 0x开头)
a, b, c, d = 20, 5.5, True, 3+4j
print(a,b,c,d)
print(type(a),type(b),type(c),type(d))
输出结果:
7.2.2 float 浮点型
用于表示数学汇总的实数,带有小数的数据类型。如:3.14 5.20
E或e表示基数是10,后面的整数表示指数。 1.5e-3 3.455e7
7.2.3 complex 复数
与数学中的复数一样。
f1 = 4 + 5j
print(f1)
print(type(f1))
print(f1.real)
print(f1.imag)
输出结果:
7.2.4 bool 布尔型
bool 是 int 的子类,True 和 False 可以和数字相加, True==1、False==0 会返回 True,但可以通过 is 来判断类型。
issubclass()会认为子类是一种父类
7.3 String 字符串
Python中的字符串用单引号 ' 或双引号 " 括起来,同时使用反斜杠 \ 转义特殊字符。
字符串的截取语法格式如下:
变量[头下标:尾下标]
索引值以 0 为开始值,-1 为从末尾的开始位置。
加号 + 是字符串的连接符, 星号 * 表示复制当前字符串,与之结合的数字为复制的次数。如下
str = 'Runoob'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次,也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串
输出结果:
Python 使用反斜杠 \ 转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个 r,表示原始字符串:
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>
反斜杠(\)可以作为续行符,表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
注意,Python 没有单独的字符类型,一个字符就是长度为1的字符串。
>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P
与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,比如word[0] = 'm'会导致错误。
注意:
- 1、反斜杠可以用来转义,使用r可以让反斜杠不发生转义。
- 2、字符串可以用+运算符连接在一起,用*运算符重复。
- 3、Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始。
- 4、Python中的字符串不能改变。
7.4 List 列表
List(列表) 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下:
变量[头下标:尾下标]
索引值以 0 为开始值,-1 为从末尾的开始位置。
加号 + 是列表连接运算符,星号 * 是重复操作。如下实例:
list = [ '小陈', 678 , 88, '拉稀吧', '跨啦' ]
tinylist = [123, '拉稀叭']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
输出结果:
与Python字符串不一样的是,列表中的元素是可以改变的:
llist内置了很多方法,如 append()、pop()等,等待下文分解
注意:
- 1、List写在方括号之间,元素用逗号隔开。
- 2、和字符串一样,list可以被索引和切片。
- 3、List可以使用+操作符进行拼接。
- 4、List中的元素是可以改变的。
Python 列表截取可以接收第三个参数,参数作用是截取的步长,以下实例在索引 1 到索引 4 的位置并设置为步长为 2(间隔一个位置)来截取字符串:
7.5 Tuple 元组
元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。元组中的元素类型也可以不相同:
tuple = ( 'yyds', 786 , 5.20, 'xiaochen', 13.14 )
tinytuple = (520, 'xiaochen')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组
输出结果:
元组与字符串类似,可以被索引且下标索引从0开始,-1 为从末尾开始的位置。也可以进行截取(看上面,这里不再赘述)。
其实,可以把字符串看作一种特殊的元组
>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11 # 修改元组元素的操作是非法的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>
虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
tup1 = () # 空元组 tup2 = (20,) # 一个元素,需要在元素后添加逗号
string、list 和 tuple 都属于 sequence(序列)。
注意:
- 1、与字符串一样,元组的元素不能修改。
- 2、元组也可以被索引和切片,方法一样。
- 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
- 4、元组也可以使用+操作符进行拼接。
7.6 Set 集合
集合(set)是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
创建格式:
parame = {value01,value02,...} 或者 set(value)
sites = {'大帅锅', '小陈', '大美女', '天才第一步', '彭于晏', '汪峰'}
print(sites) # 输出集合,重复的元素被自动去掉
# 成员测试
if '大帅锅' in sites :
print('大帅锅 在集合中')
else :
print('大帅锅 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
输出结果:
7.7 Dictionary 字典
字典(dictionary)是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中,键(key)必须是唯一的。
dict = {}
dict['one'] = "1 - 拉稀吧"
dict[2] = "2 - 不拉稀吧"
tinydict = {'name': '小陈陈','code':1, 'site': 'www.xiaochen.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
输出结果:
构造函数 dict() 可以直接从键值对序列中构建字典如下
>>> dict([('呼啦啦', 1), ('哒哒哒', 2), ('嘿嘿嘿', 3)])
{'呼啦啦': 1, '哒哒哒': 2, '嘿嘿嘿': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(大帅锅=1, 小垃圾=2, 大垃圾=3)
{'大帅锅': 1, '小垃圾': 2, '大垃圾': 3}
{x: x**2 for x in (2, 4, 6)} 该代码使用的是字典推导式,更多推导式内容可以参考:Python 推导式
另外,字典类型也有一些内置的函数,例如 clear()、keys()、values() 等。
注意:
- 1、字典是一种映射类型,它的元素是键值对。
- 2、字典的关键字必须为不可变类型,且不能重复。
- 3、创建空字典使用 { }。
8 python数据类型转换
有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可
Python 数据类型转换可以分为两种:
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
隐式类型转换
在隐式类型转换中,Python 会自动将一种数据类型转换为另一种数据类型,不需要我们去干预。
以下实例中,我们对两种不同类型的数据进行运算,较低数据类型(整数)就会转换为较高数据类型(浮点数)以避免数据丢失。
num_int = 123
num_flo = 1.23
num_new = num_int + num_flo
print("datatype of num_int:",type(num_int))
print("datatype of num_flo:",type(num_flo))
print("Value of num_new:",num_new)
print("datatype of num_new:",type(num_new))
输出结果:
num_int 数据类型为: <class 'int'> num_flo 数据类型为: <class 'float'> num_new: 值为: 124.23 num_new 数据类型为: <class 'float'>
代码解析:
- 实例中我们对两个不同数据类型的变量
num_int
和num_flo
进行相加运算,并存储在变量num_new
中。 - 然后查看三个变量的数据类型。
- 在输出结果中,我们看到
num_int
是整型(integer)
,num_flo
是浮点型(float)
。 - 同样,新的变量
num_new
是浮点型(float)
,这是因为 Python 会将较小的数据类型转换为较大的数据类型,以避免数据丢失。
我们再看一个实例,整型数据与字符串类型的数据进行相加:
num_int = 123
num_str = "456"
print("Data type of num_int:",type(num_int))
print("Data type of num_str:",type(num_str))
print(num_int+num_str)
输出:
从输出中可以看出,整型和字符串类型运算结果会报错,输出 TypeError。 Python 在这种情况下无法使用隐式转换。
但是,Python 为这些类型的情况提供了一种解决方案,称为显式转换。
显式类型转换
在显式类型转换中,用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。
int() 强制转换为整型:
x = int(1) # x 输出结果为 1
y = int(4.8) # y 输出结果为 5
z = int("6") # z 输出结果为 6
float() 强制转换为浮点型:
x = float(1) # x 输出结果为 1.0
y = float(2.8) # y 输出结果为 2.8
z = float("3") # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2
str() 强制转换为字符串类型:
x = str("s1") # x 输出结果为 's1'
y = str(2) # y 输出结果为 '2'
z = str(3.0) # z 输出结果为 '3.0'
整型和字符串类型进行运算,就可以用强制类型转换来完成
num_int = 123
num_str = "456"
print("num_int 数据类型为:",type(num_int))
print("类型转换前,num_str 数据类型为:",type(num_str))
num_str = int(num_str) # 强制转换为整型
print("类型转换后,num_str 数据类型为:",type(num_str))
num_sum = num_int + num_str
print("num_int 与 num_str 相加结果为:",num_sum)
print("sum 数据类型为:",type(num_sum))
输出结果:
num_int 数据类型为: <class 'int'> 类型转换前,num_str 数据类型为: <class 'str'> 类型转换后,num_str 数据类型为: <class 'int'> num_int 与 num_str 相加结果为: 579 sum 数据类型为: <class 'int'>
python Number类型转换:
9 python 推导式
Python 推导式是一种独特的数据处理方式,可以从一个数据序列构建另一个新的数据序列的结构体。
Python 支持各种数据结构的推导式:
- 列表(list)推导式
- 字典(dict)推导式
- 集合(set)推导式
- 元组(tuple)推导式
列表推导式
列表推导式格式为:
[表达式 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]
- out_exp_res:列表生成元素表达式,可以是有返回值的函数。
- for out_exp in input_list:迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
- if condition:条件语句,可以过滤列表中不符合条件的值。
过滤掉长度小于或等于3的字符串列表,并将剩下的转换成大写字母:
>>> 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']
计算 30 以内可以被 3 整除的整数:
>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
字典推导式
字典推导基本格式:
{ 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'>
集合推导式
集合推导式基本格式:
{ expression for item in Sequence } 或 { expression for item in Sequence if conditional }
计算数字 1,2,3 的平方数:
>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}
判断不是 abc 的字母并输出:
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>
元组推导式
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型,快速生成一个满足指定需求的元组。
元组推导式基本格式:
(expression for item in Sequence ) 或 (expression for item in Sequence if conditional )
元组推导式和列表推导式的用法也完全相同,只是元组推导式是用 () 圆括号将各部分括起来,而列表推导式用的是中括号 [],另外元组推导式返回的结果是一个生成器对象。
例如,我们可以使用下面的代码生成一个包含数字 1~9 的元组:
>>> 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)
10 python 运算符
什么是运算符嘞?
如下:
3 + 1 = 4
其中3和4被称为操作符,+称为运算符
10.1 Python算术运算符
以下假设变量 a=10,变量 b=21:
如下所示,所以算术运算符的操作:
a = 520 + 1314
b = '520' + '1314'
c = 1314 - 520
d = "我每天爱你三千编!\n" * 3
e = 1314 / 520
f = 1314 % 520
g = 1314 ** 5
h = 1314 // 520
print('a=',a)
print('b=',b)
print('c=',c)
print('你爱我吗?\n',d)
print('e=',e)
print('f=',f)
print('g=',g)
print('h=',h)
输出结果:
10.2 Python比较运算符
以下假设变量a为10,变量b为20:
a = 21
b = 10
if ( a == b ):
print ("1 - a 等于 b")
else:
print ("1 - a 不等于 b")
if ( a != b ):
print ("2 - a 不等于 b")
else:
print ("2 - a 等于 b")
if ( a < b ):
print ("3 - a 小于 b")
else:
print ("3 - a 大于等于 b")
if ( a > b ):
print ("4 - a 大于 b")
else:
print ("4 - a 小于等于 b")
if ( a <= b ):
print ("5 - a 小于等于 b")
else:
print ("5 - a 大于 b")
if ( b >= a ):
print ("6 - b 大于等于 a")
else:
print ("6 - b 小于 a")
输出结果:
python设计第一个游戏:
temp = input("不妨猜一下小陈陈现在心里想的是哪个数字:")
guess = int(temp)
if guess == 8:
print("你是小陈陈心里的蛔虫嘛?!")
print("哼,猜中了也没有奖励!")
else:
print("猜错啦,小陈陈现在心里想的是8!")
print("游戏结束,不玩啦^_^")
输出结果:
10.3 Python赋值运算符
以下假设变量a为10,变量b为20:
以下实例演示了Python所有赋值运算符的操作:
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为:", c)
c += a
print ("2 - c 的值为:", c)
c *= a
print ("3 - c 的值为:", c)
c /= a
print ("4 - c 的值为:", c)
c = 2
c %= a
print ("5 - c 的值为:", c)
c **= a
print ("6 - c 的值为:", c)
c //= a
print ("7 - c 的值为:", c)
输出结果:
1 - c 的值为: 31
2 - c 的值为: 52
3 - c 的值为: 1092
4 - c 的值为: 52.0
5 - c 的值为: 2
6 - c 的值为: 2097152
7 - c 的值为: 99864
10.4 Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:
下表中变量 a 为 60,b 为 13二进制格式如下
以下实例演示了Python所有位运算符的操作:
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b # 12 = 0000 1100
print ("1 - c 的值为:", c)
c = a | b # 61 = 0011 1101
print ("2 - c 的值为:", c)
c = a ^ b # 49 = 0011 0001
print ("3 - c 的值为:", c)
c = ~a # -61 = 1100 0011
print ("4 - c 的值为:", c)
c = a << 2 # 240 = 1111 0000
print ("5 - c 的值为:", c)
c = a >> 2 # 15 = 0000 1111
print ("6 - c 的值为:", c)
输出结果:
1 - c 的值为: 12
2 - c 的值为: 61
3 - c 的值为: 49
4 - c 的值为: -61
5 - c 的值为: 240
6 - c 的值为: 15
10.5 Python逻辑运算符
Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:
以上实例输出结果:
a = 10
b = 20
if ( a and b ):
print ("1 - 变量 a 和 b 都为 true")
else:
print ("1 - 变量 a 和 b 有一个不为 true")
if ( a or b ):
print ("2 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:
print ("2 - 变量 a 和 b 都不为 true")
if not( a and b ):
print ("3 - 变量 a 和 b 都为 false,或其中一个变量为 false")
else:
print ("3 - 变量 a 和 b 都为 true")
输出结果:
10.6 Python成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
a = '小陈'
b = '小芳'
list = ['小王','老王','小芳']
if(a in list):
print("小陈在list列表中")
else:
print("小陈不在list列表中")
if(b not in list):
print("小芳不在list列表中")
else:
print("小芳在list列表中")
输出结果:
10.7 Python身份运算符
身份运算符用于比较两个对象的存储单元
注: id() 函数用于获取对象内存地址。
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的标识")
else:
print ("1 - a 和 b 没有相同的标识")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的标识")
else:
print ("2 - a 和 b 没有相同的标识")
输出结果:
is 与 == 区别:
is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
10.8 Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符:
以下实例演示了Python所有运算符优先级的操作:
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为:", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为:", e)
e = (a + b) * (c / d) # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为:", e)
e = a + (b * c) / d # 20 + (150/5)
print ("a + (b * c) / d 运算结果为:", e)
输出结果:
(a + b) * c / d 运算结果为: 90.0 ((a + b) * c) / d 运算结果为: 90.0 (a + b) * (c / d) 运算结果为: 90.0 a + (b * c) / d 运算结果为: 50.0
and 拥有更高优先级:
x = True
y = False
z = False
if x or y and z:
print("yes")
else:
print("no")
输出结果:
yes
注意:Pyhton3 已不支持 <> 运算符,可以使用 != 代替,如果你一定要使用这种比较运算符,可以使用以下的方式:
>>> from __future__ import barry_as_FLUFL
>>> 1 <> 2
True
11 python3 Number 数字
Python 数字数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值,将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建:
var1 = 520 var2 = 1314
您也可以使用del语句删除一些数字对象的引用。
del语句的语法是:
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象的引用,例如:
del var del var_a, var_b
Python 支持三种不同的数值类型:
-
整型(int) - 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
-
浮点型(float) - 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250)
-
复数( (complex)) - 复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。
我们可以使用十六进制和八进制来代表整数
>>> number = 0xA0F # 十六进制
>>> number
2575
>>> number=0o37 # 八进制
>>> number
31
- Python支持复数,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。
11.1 Python 数字类型转换
有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
-
int(x) 将x转换为一个整数。
-
float(x) 将x转换到一个浮点数。
-
complex(x) 将x转换到一个复数,实数部分为 x,虚数部分为 0。
-
complex(x, y) 将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。
以下实例将浮点数变量 a 转换为整数:
>>> a = 1314.0
>>> int(a)
1314
11.2 Python 数字运算
Python 解释器可以作为一个简单的计算器,您可以在解释器里输入一个表达式,它将输出表达式的值。
表达式的语法很直白: +, -, * 和 /, 和其它语言(如Pascal或C)里一样。例如:
>>> 1314 + 520
1834
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 总是返回一个浮点数
1.6
注意:在不同的机器上浮点运算的结果可能会不一样。
在整数除法中,除法 / 总是返回一个浮点数,如果只想得到整数的结果,丢弃可能的分数部分,可以使用运算符 // :
>>> 17 / 3 # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3 # 整数除法返回向下取整后的结果
5
>>> 17 % 3 # %操作符返回除法的余数
2
>>> 5 * 3 + 2
17
注意:// 得到的并不一定是整数类型的数,它与分母分子的数据类型有关系。
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
等号 = 用于给变量赋值。赋值之后,除了下一个提示符,解释器不会显示任何结果。
>>> width = 20
>>> height = 5*9
>>> width * height
900
Python 可以使用 ** 操作来进行幂运算:
>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2的7次方
128
变量在使用前必须先"定义"(即赋予变量一个值),否则会出现错误:
>>> n # 尝试访问一个未定义的变量
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
在交互模式中,最后被输出的表达式结果被赋值给变量 _ 。例如:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
此处, _ 变量应被用户视为只读变量。
11.3 数学函数
11.4 随机数函数
随机数可以用于数学,游戏,安全等领域中,还经常被嵌入到算法中,用以提高算法效率,并提高程序的安全性。
Python包含以下常用随机数函数:
11.5 三角函数
11.6 数学常量
12 字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。
创建字符串很简单,只要为变量分配一个值即可。例如:
var1 = 'Hello World!'
var2 = "菜鸟小陈陈"
12.1 Python 访问字符串中的值
Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串,可以使用方括号 [] 来截取字符串,字符串的截取的语法格式如下
变量[头下标:尾下标]
索引值以 0 为开始值,-1 为从末尾的开始位置。
如下:
var1 = 'Hello World!'
var2 = "xiaochen"
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
输出结果:
12.2 Python 字符串更新
你可以截取字符串的一部分并与其他字段拼接,如下实例:
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + '菜鸟小陈!')
结果如下:
12.3 python转义字符
在需要在字符中使用特殊字符时,python 用反斜杠 \ 转义字符。如下表:
转义字符 | 描述 | 实例 |
\(在行尾时) | 续行符 | >>> print("line1 \ ... line2 \ ... line3") line1 line2 line3 >>> |
\\ | 反斜杠符号 | >>> print("\\") \ |
\' | 单引号 | >>> print('\'') ' |
\" | 双引号 | >>> print("\"") " |
\a | 响铃 | >>> print("\a")执行后电脑有响声 |
\b | 退格(Backspace) | >>> print("Hello \b World!") Hello World! |
\e | 转义 | |
\000 | 空 | >>> print("\000") >>> |
\n | 换行 | >>> print("\n") >>> |
\v | 纵向制表符 | >>> print("Hello \v World!") Hello World! >>> |
\t | 横向制表符 | >>> print("Hello \t World!") Hello World! >>> |
\r | 回车,将 \r 后面的内容移到字符串开头,并逐一替换开头部分的字符,直至将 \r 后面的内容完全替换完成。 | >>> print("Hello\rWorld!") World! >>> print('google xiaochen taobao\r123456') 123456 xiaochen taobao |
\f | 换页 | >>> print("Hello \f World!") Hello World! >>> |
\yyy | 八进制数,y 代表 0~7 的字符,例如:\012 代表换行 | >>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World |
\xyy | 十六进制数,以 \x 开头,y 代表的字符,例如:\x0a 代表换行 | >>>print("\x48\x65\x6c\x6c\x6f\x20 \x57\x6f\x72\x6c\x64\x21") Hello World! |
\other | 其它的字符以普通格式输出 |
12.4 Python字符串运算符
下表实例变量 a 值为字符串 "Hello",b 变量值为 "Python":
例:
a = "Hello"
b = "Python"
print("a + b 输出结果:", a + b)
print("a * 2 输出结果:", a * 2)
print("a[1] 输出结果:", a[1])
print("a[1:4] 输出结果:", a[1:4])
if( "H" in a) :
print("H 在变量 a 中")
else :
print("H 不在变量 a 中")
if( "M" not in a) :
print("M 不在变量 a 中")
else :
print("M 在变量 a 中")
print (r'\n')
print (R'\n')
输出结果:
a + b 输出结果: HelloPython a * 2 输出结果: HelloHello a[1] 输出结果: e a[1:4] 输出结果: ell H 在变量 a 中 M 不在变量 a 中 \n \n
12.5 Python 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法
print ("我叫 %s 今年 %d 岁!" % ('小chen', 15))
输出结果:
我叫 小chen 今年 15 岁!
python字符串格式化符号:
格式化操作符辅助指令:
12.6 Python三引号
python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。实例如下
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
输出:
这是一个多行字符串的实例 多行字符串可以使用制表符 TAB ( )。 也可以使用换行符 [ ]。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来,自始至终保持一小块字符串的格式是所谓的WYSIWYG(所见即所得)格式的。
一个典型的用例是,当你需要一块HTML或者SQL时,这时用字符串组合,特殊字符串转义将会非常的繁琐
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
12.7 f-string
f-string 是 python3.6 之后版本添加的,称之为字面量格式化字符串,是新的格式化字符串的语法。
之前我们习惯用百分号 (%):
>>> name = '小姐姐'
>>> 'Hello %s' % name
'Hello 小姐姐'
f-string 格式化字符串以 f 开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去,实例如下:
>>> name = 'xiaoChen'
>>> f'Hello {name}' # 替换变量
'Hello xiaoChen'
>>> f'{1+2}' # 使用表达式
'3'
>>> w = {'name': 'xiao_chen', 'url': 'www.xiaochen.com'}
>>> f'{w["name"]}: {w["url"]}'
'xiao_chen: www.xiaochen.com'
用了这种方式明显更简单了,不用再去判断使用 %s,还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果:
>>> x = 1
>>> print(f'{x+1}') # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}') # Python 3.8
x+1=2
12.8 Unicode 字符串
在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中,所有的字符串都是Unicode字符串。
12.9 Python 的字符串内建函数
Python 的字符串常用内建函数如下:
序号 | 方法及描述 |
---|---|
1 | capitalize() |
2 | 返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。 |
3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
4 | bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。 |
5 | encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace' |
6 | endswith(suffix, beg=0, end=len(string)) |
7 | 把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。 |
8 | find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1 |
9 | index(str, beg=0, end=len(string)) 跟find()方法一样,只不过如果str不在字符串中会报一个异常。 |
10 | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
11 | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
12 | 如果字符串只包含数字则返回 True 否则返回 False.. |
13 | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False |
14 | 如果字符串中只包含数字字符,则返回 True,否则返回 False |
15 | 如果字符串中只包含空白,则返回 True,否则返回 False. |
16 | 如果字符串是标题化的(见 title())则返回 True,否则返回 False |
17 | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False |
18 | 以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
19 | 返回字符串长度 |
20 | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。 |
21 | 转换字符串中所有大写字符为小写. |
22 | 截掉字符串左边的空格或指定字符。 |
23 | 创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。 |
24 | 返回字符串 str 中最大的字母。 |
25 | 返回字符串 str 中最小的字母。 |
26 | 把 将字符串中的 old 替换成 new,如果 max 指定,则替换不超过 max 次。 |
27 | rfind(str, beg=0,end=len(string)) 类似于 find()函数,不过是从右边开始查找. |
28 | rindex( str, beg=0, end=len(string)) 类似于 index(),不过是从右边开始. |
29 | 返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串 |
30 | 删除字符串末尾的空格或指定字符。 |
31 | split(str="", num=string.count(str)) 以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串 |
32 | 按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。 |
33 | startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。 |
34 | 在字符串上执行 lstrip()和 rstrip() |
35 | 将字符串中大写转换为小写,小写转换为大写 |
36 | 返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle()) |
37 | translate(table, deletechars="") 根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
38 | 转换字符串中的小写字母为大写 |
39 | 返回长度为 width 的字符串,原字符串右对齐,前面填充0 |
40 | 检查字符串是否只包含十进制 |