一、数据类型和变量
数据类型
Python3中有六个标准的数据类型:
- Number(数字):int、float、bool、complex(复数)
- String(字符串)
- List(列表)
- Tuple(元组)
- Set(集合)
- Dictionary(字典)
不可变数据:Number、String、Tuple。
可变数据:List、Set、Dictionary。
布尔值可以用and、or和not运算。
and(和运算):都为True,运算结果才为True。
or(或运算):其中一个为True,运算结果就为True。
not(非运算):是一个单目运算,把True变为False,False变为True:not True
输出 False
注:字符串可以用'''...'''的格式表示多行。
变量
变量不仅可以是数字,也可以是任何数据类型。
变量名必须是大小写英文、数字和_的组合,且不能是数字开头。
同一个变量可以反复赋值,可以是不同类型的变量。
a = "abc"
python解释器做的事情:
1.在内存中创建了一个"abc"的字符串;
2.在内存中创建了一个名为a的变量,并指向'abc'。
把变量a赋值给另一个变量b:
常量
就是不能变的变量,例如数学常数Π。在Python中,通常全部大写的变量名表示常量:
PI = 2.14159265339
但PI仍然是一个变量
整数的除法为什么也是精确的。在Python中有两种触发,一种是/
/
除法计算结果是浮点数,即使是两个整数恰好整除,结果也是浮点数。
还有一种是//
,称为地板除,两个整数的除法仍然是整数,永远都整数,不管除不除得尽。所以要做精确除法使用/
,因为//
只取整数部分。
余数运算%
注:对于变量x = y
是把x
指向真正得对象,该对象是变量y
所指向的。随后对变量y
的赋值不影响变量x
的指向。
Python的整数没有大小限制。Python的浮点数也没有大小限制,但是超出一定范围就直接表示为inf
(无限大)
二、字符串和编码
字符编码
字符串是数据类型,但是字符串比较特殊的是有一个编码问题。
因为计算机只能处理数字,如果处理文本,就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节。比如两个字节可以表示的最大整数是65535,4个字节可以表示的最大整数是4294967295。
在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或需要传输的时候,就转换为UTF-8编码。
用记事本编辑的时候,从文件读取的UTF-8字符被转换成Unicode字符到内存中,编辑完成后,保存的时候再把Unicode转换为UTF-8保存到文件。
Python的字符串
在最新的Python 3
版本中,字符串是以Unicode
编码的,也就是说,Python
的字符串支持多语言。
获取字符码:
单个字符:ord()
例:
ord("A") #65
ord("中") #20013
把编码转换成对应的字符:chr()
例:
chr(20013) #中
str转bytes
由于Python的字符串类型是str
,在内存中以Unicode
表示,一个字符串对应若干个字节(bytes
)。
所以对于bytes类型的数据自带b前缀的单引号或双引号表示:
x = b'ABC'
"ABC"和b"ABC"是不一样的。
以Unicode
表示的str
通过encode()
方法可以编码为指定的bytes
,例如:
英文的str可以用
ASCII
编码为bytes
,内容是一样的。含中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码,会报错。bytes转str
要把
bytes
变为str
,就需要用decode()
方法。如果bytes
中包含无法解码的字节,decode()
方法会报错。如果
bytes
中只有一小部分无效的字节,可以传入errors='ignore'
忽略错误的字节。
获取str的字符长度,可以用len()
函数,也可以用来计算字节数。
Python的源代码是一个文本文件,所以在源码中包含中文的时候,在保存源码的时,就要指定UTF-8编码。在文件开头写这两句:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows会忽略这行注释。
第二行就是指定文件是UTF-8编码,否则在源码中方写的中文输可能会乱码。
格式化
-
%
运算符
%
运算符用来格式化字符串。在字符串内部,%s表示用字符串替换,%d表示用整数替换,有几个%?占位符,后面就跟几个变量或者值,顺序要对应好。如果只有一个%?,括号可以省略。
image.png
常见占位符:
image.png
其中,格式化整数和浮点数还可以指定是否补0和整数与小数的位数:
image.png
不确定用什么,%s
永远起作用,会把任何数据类型转换成字符串:
>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'
%
是普通字符串,需要转义用%%
表示
- format()
另一种格式化字符串的方法是使用字符串的format()方法,它会用传入的参数依次替换字符串内的占位符{0}、{1}……,不过这种方式写起来比%要麻烦得多:
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'
- f-string
最后一种格式化字符串的方法是使用以f开头的字符串,称之为f-string,它和普通字符串不同之处在于,字符串如果包含{xxx},就会以对应的变量替换:
>>> r = 2.5
>>> s = 3.14 * r ** 2
>>> print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62
上述代码中,{r}被变量r的值替换,{s:.2f}被变量s的值替换,并且:后面的.2f指定了格式化参数(即保留两位小数),因此,{s:.2f}的替换结果是19.62。
练习
小明的成绩从去年的72分提升到了今年的85分,请计算小明成绩提升的百分点,并用字符串格式化显示出'xx.x%',只保留小数点后1位:
s1 = 72
s2 = 85
r = ???
print("xxx" % r)
解题:
s1 = 72
s2 = 85
r = (s2 - s1)/s1*100
print(r)
#%运算符
print("小明的成绩提高了 %.1f %%" % r)
#format
print("小明的成绩提高了 {0:.1f}%".format(r))
#f-string
print(f"小明的成绩提高了 {r:.1f} %")
三、list和tuple
list数组 []
list是一种有序集合,可以随时添加和删除其中的元素。
>>> classmates = ["xiaoming","xiaofang","xiaoli"]
>>> classmates
['xiaoming', 'xiaofang', 'xiaoli']
- 获取元素个数
len()
>>> len(classmates)
3
- 通过索引来获取元素,可以是负数,-1就是最后一个,以此类推
>>> classmates[0]
'xiaoming'
索引超出范围会报错 IndexError
- 添加元素
append()
>>> classmates.append("xiaoxiao")
>>> classmates
['xiaoming', 'xiaofang', 'xiaoli', 'xiaoxiao']
- 把元素插入指定位置
insert(索引,插入元素)
>>> classmates.insert(0,"xiaoying")
>>> classmates
['xiaoying', 'xiaoming', 'xiaofang', 'xiaoli', 'xiaoxiao']
- 删除末尾元素
pop()
>>> classmates.pop()
'xiaoxiao'
>>> classmates
['xiaoying', 'xiaoming', 'xiaofang', 'xiaoli']
- 删除指定位置的元素
pop(i)
>>> classmates.pop(1)
'xiaoming'
>>> classmates
['xiaoying', 'xiaofang', 'xiaoli']
- 重新赋值
>>> classmates[2] = "xiaoxiao"
>>> classmates
['xiaoying', 'xiaofang', 'xiaoxiao']
- list的元素可以是不同数据类型,也可以是多维数组
>>> L = ["string",123,True]
tuple元组 ()
tuple和list非常相似,但是一旦初始化就不能修改,比如:
>>> classmates = ("xiaoying","xiaofang","xiaoxiao")
但是tuple的元素不能变了,没有append(),insert()这些方法。
- tuple存在的意义?
因为tuple不可变,所以代码更安全。所以能用tuple就不用list - 空的tuple
>>> t = ()
- 定义一个元素的tuple
>>> t = (1)
>>> t
1
定义的不是tuple,是1这个数,因为括号既可以表示tuple,又可以表示数学公式的(),这就有歧义了。所以,Python规定,这种情况下,按小括号进行计算,所以结果是1。
所以定义tuple定义时必须加上一个逗号,
,来消除歧义。
>>> t = (1,)
>>> t
(1,)
>>>
- tuple的每个元素的指向不变
即指向了'a'
,就不能改成指向'b'
,指向一个list,就不能改成指向其他对象,但指向的这个list本身时可变的!
>>> t = ("a","b",["A","B"])
>>> t[2][0] = "X"
>>> t[2][1] = "Y"
>>> t
('a', 'b', ['X', 'Y'])
练习
请用索引取出下面的list的指定元素:
# -*- coding: utf-8 -*-
L = [
['Apple', 'Google', 'Microsoft'],
['Java', 'Python', 'Ruby', 'PHP'],
['Adam', 'Bart', 'Lisa']
]
# 打印Apple:
print(?)
# 打印Python:
print(?)
# 打印Lisa:
print(?)
解答:
print(L[0][0])
print(L[1][1])
print(L[2][-1])
四、条件判断
-
if
else
else if
(缩写elif
)
注意有冒号:
语法:
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
例:
age = 3
if age >= 18:
print("adult")
elif age >= 6:
print("teenager")
else:
print("kid")
- 结合输入
input()
input()
返回的数据类型是str,str不能和整数比较,必须先转化成整数。
int()
函数,将其他类型转换成整数,转换之后就只能输入整数了,不然会报错。
age = 3
if age >= 18:
print("adult")
elif age >= 6:
print("teenager")
else:
print("kid")
s = input("生日:")
birth = int(s)
if birth < 2000:
print("00前")
else:
print("00后")
练习
小明身高1.75,体重80.5kg。请根据BMI公式(体重除以身高的平方)帮小明计算他的BMI指数,并根据BMI指数:
低于18.5:过轻
18.5-25:正常
25-28:过重
28-32:肥胖
高于32:严重肥胖
用 if-elif判断并打印结果:
height = 1.75
weight = 80.5
bmi = ???
if ???:
pass
解答:
height = 1.75
weight = 80.5
bmi = weight/height**2 #**n表示n次平方
if bmi < 18.5:
print("过轻")
elif bmi <= 25:
print("正常")
elif bmi <= 28:
print("过重")
elif bmi <= 32:
print("肥胖")
else:
print("严重肥胖")
五、循环
-
for ... in
循环
names = ["xiaoying","xiaofang","xiaoxiao"]
for name in names:
print(name)
①循环相加
sum = 0
for num in [1,2,3,4,5,6,7,8,9,10]:
sum = sum + num
print(sum)
②通过range()
函数生成整数序列,再用list()
转换成list。
>>> list(range(5))
[0, 1, 2, 3, 4]
计算 1-100的整数相加:
sum = 0
for x in list(range(101)):
sum = sum + x
print(sum)
-
while
循环
只要条件满足,就不断循环,条件不满足时就退出循环。
计算100以内的奇数之和:
sum = 0
x = 99
while x > 0:
sum = sum + x
x = x - 2
print(sum)
- 练习
请利用循环依次对list中的每个名字打印Hello,xxx!
L = ['Bart', 'Lisa', 'Adam']
解答:
L = ['Bart', 'Lisa', 'Adam']
for name in L:
print("Hello,"+name+"!")
-
break
提前退出循环
打印1-100之间的1-10
n = 1
while n <= 100:
if n > 10: #当n>10的时候,就会退出循环
break
print(n)
n = n + 1
-
continue
跳出当前循环,进入下一次循环
打印 1-10之间的奇数
n = 0
while n < 10:
n = n + 1
if n % 2 == 0: #当n为偶数时
continue
print(n)
六、dict和set
dict字典
Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。
例:
>>> d = {"xiaoming":98,"xiaofang":78,"xiaoxiao":99}
>>> d["xiaoming"]
98
- 写入值,通过key
>>> d["xiaoqian"] = 87
>>> d
{'xiaoming': 98, 'xiaofang': 78, 'xiaoxiao': 99, 'xiaoqian': 87}
- 获取值
如果key不存在的话会报错
>>> d["xiaoqian"]
87
- 避免key不存在的错误
①通过in
判断key是否存在
>>> "xiao" in d
False
②通过dict提供的get()
方法,如果key不存在,就返回None
(不会显示),或者自己指定的值
>>> d.get("xiao",-1)
-1
- 删除key,
pop(key)
>>> d.pop("xiaoxiao")
99
>>> d
{'xiaoming': 98, 'xiaofang': 78, 'xiaoqian': 87}
注:dict存放的顺序可key放入的顺序没有关系。
和list比较,dict有以下几个特点:
1.查找的插入的速度快,不会随着key的增加而变慢;
2.占用空间小。浪费内存少。
所以dict是用空间来换取时间的一种方法。
注:dict的key必须是不可变对象。
因为dict根据key计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。
要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key:
set
set和dict相似,也是一组key的集合,但不存储value。由于key不能重复,所以在set中,没有重复的key。
要创建一个set,需要提供一个list作为输入集合:
>>> s = set([1,2,3])
>>> s
{1, 2, 3}
注:传入的是[],显示的{}只是告诉你这个set内部有这几个元素,显示的顺序也不代表set是有序的。
重复的元素在set中自动过滤:
>>> s = set([1,2,4,5,7,8,2,5,7])
>>> s
{1, 2, 4, 5, 7, 8}
- 添加元素
add(set)
>>> s.add(9)
>>> s
{1, 2, 4, 5, 7, 8, 9}
- 删除元素 remove(key)
>>> s.remove(9)
>>> s
{1, 2, 4, 5, 7, 8}
set可以看作是数学意义上的无序和无重复的集合,所以可以做交集、并集操作:
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set和dict的原理是一样的,不可以放入可变对象,因为无法判断两个可变对象是否相等。也就无法保证set内部不会有重复元素,会报错。区别在于set没有存储对应的value。
- 不可变对象
str不可变对象,list可变对象。
对可变对象进行操作,内容有可能会发生变化,而不可变对象是不会有改变的。
>>> a = ["c","b","a"]
>>> a.sort()
>>> a
['a', 'b', 'c']
>>> a = "abc"
>>> a.replace("a","A")
'Abc'
>>> a
'abc'
>>>
为什么a的值仍然是"abc"呢?
因为 a是变量,指向的是"abc"这个字符串对象。
而replace()方法作用在"abc"这个对象上会创建一个新的字符串"Abc"并返回,"abc"这个对象是不可变的,所以用另一个变量b赋值就让b指向"Abc"了。
>>> a = "abc"
>>> b = a.replace("a","A")
>>> a
'abc'
>>>b
'Abc'
结:
在dict中的key-value存储结构,选择不可变对象作为key很重要,最常用的key是字符串。
试一试把(1,2,3)和(1,[2,3])放入dict或set中,并解释结果。
>>> key = (1,2,3)
>>> d[key] = "a dict"
>>> d
{'xiaoming': 98, 'xiaofang': 78, 'xiaoqian': 87, (1, 2, 3): 'a dict'}
>>> key = (1,[2,3])
>>> d[key] = "a dict"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> s.add((1,2,3))
>>> s
{1, 2, 4, 5, 7, 8, (1, 2, 3)}
>>> s.add((1,[2,3]))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
解释:
tuple是不可变对象,list是可变对象,在set和dict中都不可以放入可变对象,因为无法判断两个可变对象是否相等,无法判断key是否是唯一的了。