文章目录
词
布尔
一. 布尔类型
布尔类型的两个值： -True -False
内置函数：bool
>>>True
True
>>>False
False
>>>type(True)
<class 'bool'>
>>>'True'
'True'
>>>'p' in 'pthon'
True
>>>'u' in 'python'
False
>>>bool("p")
True
>>>bool(0)
False
>>>bool(str())
False
>>>bool(' ')
True
>>>int()
0
>>>bool(int())
False
二. 比较
比较大小
>>>3 > 4
False
>>>3.5>3
True
>>>'abc' > 'bcd'
False
>>>ord('a')
97
>>>ord('b')
98
>>>'250' > 250 #除整数与浮点数可进行比较，其他只有同类型间才可以比较大小
比较运算符
== != > < >= <=
列表
一. 创建列表
列表中的元素可以是任何类型的对象，列表是个筐什么都能装
>>>list('python')
['p', 'y', 't', 'h', 'o', 'n']
>>>list()
[]
>>>[]
[]
二. 索引和切片
序列：字符串、列表
-索引和切片 与字符串相同
-基本操作 与字符串相同
>>>lst = [1, 3.14, 'python', ' ', True, False, [1, 2, 3]]
>>>lst[:4]
[1, 3.14, 'python', ' ']
>>>lst[::-1]
[[1, 2, 3], False, True, ' ', 'python', 3.14, 1]
>>>lst1 = [1, 2, 3]
>>>lst2 = ['a', 'b', 'c']
>>>lst1 + lst2
[1, 2, 3, 'a', 'b', 'c']
lst1 * 2
[1, 2, 3, 1, 2, 3]
列表的元素可以修改，但列表对象不变
-通过索引修改相应元素--字符串则不能
>>>lst[1] = 99
>>>lst
[1, 99, 'python', ' ', True, False, [1, 2, 3]] #更改过后的列表的地址与之前的列表地址相同
三. 列表的方法
增加列表的元素
dir(list） #查看list有哪些函数
help(lst.append) #查看append方法
>>>lst.append(888)
>>>lst
[1, 99, 'python', ' ', True, False, [1, 2, 3], 888] #追加过后的列表地址仍然不会改变
>>>lst.insert(0, 'book')
>>>lst
['book', 1, 99, 'python', ' ', True, False, [1, 2, 3], 888]
>>>lst.extend(lst1)
>>>lst
['book', 1, 99, 'python', ' ', True, False, [1, 2, 3], 888, 1, 2, 3]
>>>lst.append(99)
>>>lst
['book', 1, 99, 'python', ' ', True, False, [1, 2, 3], 888, 1, 2, 3, 99]
删除列表的元素
>>>lst.remove(99)
>>>lst
['book', 1, 'python', ' ', True, False, [1, 2, 3], 888, 1, 2, 3, 99]
>>>lst.pop() #默认参数为-1，即不填索引的话就删除最后一个
99
>>>lst.pop(2)
'python'
>>>lst1.clear()
>>>lst1
[]
>>>lst1 = [2, 4, 1, 6, 2, 4]
排序和反转
>>>lst1.sort() #从小到大排序
>>>lst1
[1, 2, 2, 4, 4, 6]
>>>lst1. reverse() #将之前的序列反转
>>>lst1
[6, 4, 4, 2, 2, 1]
>>>sorted(lst1) #重新生成了一个新的列表，原列表没有改变
[1, 2, 2, 4, 4, 6]
>>>lst1
[6, 4, 4, 2, 2, 1]
>>>reversed(lst1)
#会返回一个迭代器对象
>>>list(reversed(lst1)) #查看生成的新的反转后的列表
[1, 2, 3, 4, 4, 6]
元组
一. 创建元祖
任何类型的对象都可以作为元素
>>>t = (1, 3.14, [1, 2, 3], True, ())
>>>type(t)
<class 'tuple'>
>>>()
()
>>>tuple()
()
bool(tuple())
False
>>>tuple('python')
('p', 'y', 't', 'h', 'o', 'n')
>>>(3,)
(3,)
>>>type(('hello'))
<class 'str'>
>>>type(('hello',)) #只有一个元素的元组需要在元素后面加逗号
<class 'tuple'>
>>>[1] #只有一个元素的列表则元素后加不加逗号则都可以
[1]
>>>[1,]
[1]
二. 常用操作
序列：字符串、列表、元组
-索引和切片--与字符串相同
-基本操作--与字符串相同
>>>t = (1, 3.14, [1, 2, 3], True, ())
>>>t[0]
1
>>>t[2]
[1, 2, 3]
>>>t[::2]
(1, [1, 2, 3], ())
>>>t{1:]
(3.14, [1, 2, 3], True, ())
>>>t1 = (1, 2, 3)
>>>t2 = (4, 5, 6)
>>>t1 + t2
(1, 2, 3, 4, 5, 6)
>>>t1 * 2
(1, 2, 3, 1, 2, 3)
>>>1 in t1
True
元组的元素不可以修改
-这是与列表的区别
>>>t[2] = 999 ×
元组与列表之间的转换
>>>tlst = list(t)
>>>tlst
[1, 3.14, [1, 2, 3], True, ()]
>>>tlst[1] = 314
>>>tlst
[1, 314, [1, 2, 3], True, ()]
>>>tuple(tlst)
(1, 314, [1, 2, 3], True, ())
三. 元组的必要性
元组比列表操作速度快
元组能够对不需要修改的数据写保护
元组可以作为字典的键
字典
引言
>>>Cities=[‘shanghai’,‘soochow’,hangzhou’]
>>>Phones=[‘021’,‘0512’,‘0571’]
>>>’{0}:{1}’.format(cities[0],phones[0])
‘shanghai:021’
一. 创建字典
字典：用来存储映射关系
>>>d={'shanghai':'021','soochow':'0512,hangzhou':'0571'}
>>>type(d)
<class 'dict'>
key:不可变对象，唯一 value：任意对象，不唯一
>>>{1:'a',2:['a','b'],(2,):['a','b'],'hello':{1:"a"},1:'python'}
{1:'python',2:['a','b'],(2,):['a','b'],'hello':{1:'a'}}
内置函数：
>>>dict{}
{}
>>>dict(a=1,b=2,c=3)
{'a':1,'b':2,'c':3}
二. 基本操作
key相当于序列中的索引，可以用来查找、替换、增加value：
>>>d
{'shanghai':'021','soochow':'0512,hangzhou':'0571'}
>>>d['shanghai']
'021'
>>>d['shanghai']='123'
>>>d
{'shanghai':'123','soochow':'0512,hangzhou':'0571'}
>>>d['beijing;]='010' （列表则不可以通过序列的方式增加元素，只能通过name.append(' ')
>>>d
{'shanghai':'123','soochow':'0512,hangzhou':'0571','beijing':'010'}
>>>len(d)
4
>>>'shanghai' in d （只能判断key是否在字典中
True
>>>del d['shanghai']
>>>d
{'soochow':'0512,hangzhou':'0571','beijing':'010'}
字典也是个筐，删除更改增加键值对字典内存地址不影响
三. 字典的方法
读取值的方法
-get
>>>d.get('suzhou')
>>>r=d.get('suzhou')
>>>r
>>>print(r)
None
>>>d,get('suzhou','0512')
'0512'
-setdefault
>>>d.setdefault('suzhou','0512'） （也可实现添加键值对
'0512'
>>>d
{'soochow':'0512,hangzhou':'0571','beijing':'010','suzhou','0512'}
>>>d.setdefault('tianjin')
>>>d
{'soochow':'0512,hangzhou':'0571','beijing':'010'.'tianjin':None}
>>>d.setdefault('soochow')
'0512'
>>>d
{'soochow':'0512,hangzhou':'0571','beijing':'010','suzhou','0512'}
增加键值对
-update
d1.update(d2) #把d2的元素加到d1后面
d1.update(key=value) #把括号内元素加到d1后面
删除键值对
-pop
>>>d
{'soochow':'0512,hangzhou':'0571','beijing':'010','suzhou','0512'}
>>>d.pop('soochow')
'0512'
>>>d
{hangzhou':'0571','beijing':'010','suzhou','0512'}
>>>d.pop('soochow','0512')
'0512'
-popitem
>>>d.popitem()
('suzhou','0512')
>>>d
{hangzhou':'0571','beijing':'010'}
-clear
集合
一. 集合的特点：
无序性：
>>>s={1,2,3}
>>>type(s)
<class 'set'>
>>>s2={2,1,3}
>>>[1,2,3]==[2,1,3]
False (列表是有序的
>>>s==s2
True （集合是无序的
凡是用花括号的都不是序列（字典、集合），都不具有index
互异性：
>>>s={1,2,2,3}
>>>s
{1,2,3}
>>>lst=[1,2,3,3,4,4,5]
>>>set(lst) #用集合的内置函数将列表去重
{1,2,3,4,5}
>>>set() #用内置函数创建了一个空集合
set()
确定性：
>>>{1,'hello',(1,2),[1,2,3]} ×(列表是可变类型，该集合不可被创建
列表和字典都是可变对象，均不可作为集合元素
>>>s=set([1,2,3])
{1,2,3}
>>>fs=frozenset([1,2,3]) #这种方式及创建的集合为不可变类型
>>>fs
frozenset({1,2,3})
二. 集合的方法：
增加元素的方法：
>>>s
{1,2,3}
>>>s.add(99)
>>>s
{99,1,2,3}
>>>s.update(set(["hello','python'])) #用一个集合更新一个集合
>>>s
{1,2,99,3,'hello','python'}
删除元素的方法：
>>>s.pop() #删除一个元素且返回这个元素
1
>>>s
{2,99,3,'hello','python'}
>>>s.remove(3)
>>>s
{2,99,'hello','python'}
>>>s.discard(2)
>>>s
{99,'hello','python'}
>>>s.remove(2)
KeyError:2
>>>s.discard(2)
三. 集合的关系和运算
元素与集合的关系：
>>>s
{99,'hello','python'}
>>>99 in s
True
>>>2 in s
False
集合与集合的关系：
>>>a=set([1,2,3,4,5,6])
>>>b=set([1,2,3])
>>>a.issuperset(b)
True
>>>a.issubset(b)
False
集合间运算：
>>>a=set([1,2,3,4,5,6])
>>>b=set([1,2,7,8,9])
并集：
>>>a.union(b)
{1,2,3,4,5,6,7,8,9}
>>>a | b
{1,2,3,4,5,6,7,8,9}
交集：
>>>a.intersection(b)
{1,2}
>>>a & b
{1,2}
差集：
>>>a.difference(b)
{3,4,5,6}
>>>a - b
{3,4,5,6}
>>>b.difference(a)
{7,8,9}
>>>b - a
{7,8,9}
浅拷贝和深拷贝
容器：列表、元组、字典、（可变）集合
列表、字典、集合：
浅拷贝:
>>>lst=[1,2,3]
>>>lst2=lst.copy() (id(lst)≠id(lst2)
>>>lst
[1,2,3]
>>>lst(2)
[1,2,3]
>>>lst.append(99)
>>>lst
[1,2,3,99]
>>>lst2
[1,2,3]
>>>lst=[[1,2,3]]
>>>lst2=lst.copy() (id(lst)≠id(lst2)但id(lst[0]=id(lst2[0])
>>>lst[0].append(888)
>>>lst
[[1,2,3,888]]
>>>lst2
[[1,2,3,888]]
浅拷贝只拷贝最外一层的容器，里面的容器还是引用相同的对象
深拷贝：
>>>import copy
>>>lst
[[1,2,3,888]]
>>>dlst=copy.deepcopy(lst)
>>>dlst
[[1,2,3,888]] (id(lst)≠id(dlst)且·id(lst[0])≠id(dlst[0])
“句”
逻辑运算
一. 运算和运算符：
算术：+,-,*,/,//,%,**
函数：import math
比较：>,<,==,!=,>=,<=
二. 逻辑与 expr1 and expr2
如果 bool(expr1)==False
返回expr1
否则：
返回expr2
>>>1 and 2
2
>>>0 and 2
0
>>>3<4 and 4>5
False
三. 逻辑或 expr1 or expr2
如果 bool(expr1)==True
返回expr1
否则：
返回expr2
>>>1 or 2
1
>>>0 or 2
2
>>>3<4 or 4>5
True
四. 逻辑非 not expr1
如果bool(expr1)==True
返回False
否则：
返回True
>>>not(1)
False
>>>not(0)
True
>>>not(3<4)
False
五. 链式表达式 1 in [1,0]==True
1 in [1,0]==True
即：
(1 in [1,0]) and ([1,0]==True)
>>>1 in [1,0]
True
>>>[1,0]==True
False
>>>(1 in [1,0]) and ([1,0]==True)
False
条件语句
>>>x = 4
>>>if x%2 == 0: #单分支
print(x)
print('x is even number')
4
x is even number
>>>if x%2 == 1
print('x is odd number')
>>>if x > 3: #多分支
print(x, 'x is more than 3')
elif x < 3 and x > 0:
print(x, 'x is less than 3')
else:
print(x, 'x is less than 0')
>>>x=3.14 #三元操作
>>>lang = 'python' if x > 3 else 'rust'
>>>lang
'python'
'''
编写程序，判断用户输入的是奇数还是偶数
'''
n = input('请输入一个自然数：')
if n.isdigit(): # n is a numeric string or not
n=int(n) # convert to integer
if n%2 ==0:
print('{0} is a even number'.format(n))
else:
print('{0} is an odd number'.format(n))
else:
print('请输入一个自然数')
'''
编写程序，判断用户输入的网站主域名是否符合规定格式要求，网站主域名格式：www.xxxx.xxx
'''
domain = input('please input a domain name:')
postfix = ('com', 'net', 'cn')
lst = domain.split('.')
if (len(lst) < 2) or (len(lst) > 4):
print('The domain does not right.')
elif lst[-1] not in postfix:
print('The domain does not comply with the regulations.')
else:
print('The domain is right.')
for循环
一. for循环语句的结构
序列都可以通过for循环，通过一个变量把序列中的每个元素循环出来：
>>>h='hello'
>>>for i in h:
print(i) #获取字符串中的每个字符
>>>lst=[1,2,3,4]
>>>for i in lst:
print(i) #获取列表中的每个元素
>>>t=tuple(lst)
>>>t
(1,2,3,4)
>>>for i in t:
print(i) #获取元组的每个元素
>>>d={'name':'laoqi','lang':'python','age':39}
>>>for k in d:
print(k) #获取字典的每个键
>>>for k in d:
print(k, d[k]) #获取字典键值对
>>>d.items():
dict_items([('name','laoqi'),('lang','python'),('age',39)])
>>>for k,v in d.items():
print(k,v) #获取字典的键值对
>>>for i in 325:
print(i) (325是不可迭代的对象，不能应用for循环）
只有可迭代的（iterable)对象可以应用for循环，判断一个对象是不是可迭代的：
>>>hasattr(d, '__iter__') #方法1
True
>>>hasattr(325, '__iter__')
False
import collections.abc #方法2
isinstance(325, collections.abc.Iterable) #判断325是不是iterable类的实例
range函数
>>>a = range(10)
>>>a
range(0,10)
>>>list(a)
[0,1,2,3,4,5,6,7,8,9]
>>>b=range(1,22,2) (不包括22）
>>>list(b)
[1,3,5,7,9,11,13,15,17,19,21]
>>>lst=[] #把100以内所有偶数追加到列表中，不包括100（效果等同于list(range(0, 100, 2))
>>>for i in range(100):
>>>if i%2 == 0:lst.append(i)
>>>lst
[0,2,4,……]
zip函数
>>>a = [1,2,3,4]
>>>b = [5,6,7,8]
>>>z=zip(a, b)
>>>z
<zip object at 0x10a592748>
>>>list(zip(a,b))
[(1,5), (2,6), (3,7), (4,8)]
>>>dict(zip(a,b))
(1:5, 2:6, 3:7, 4:8)
>>>for i in range(len(a)): #把列表a和列表b中元素对应相加
print(a[i]+b[i])
6 8 10 12
>>>lst=[] #把列表a和列表b中元素对应相加并追加到列表中
>>>for x, y in zip(a, b):
lst.append(x + y）
>>>lst
[6,8,10,12]
>>>seasons = ['spring', 'summer', 'fall', 'winter'] #打印列表中的序号和元素
>>>for i in range(len(seasons)):
print(i, seasons[i])
enumerate函数
>>>list(enumerate(seasons))
[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]
>>>for i, e in enumerate(seasons): #用enumerate函数打印列表中的序号和元素
print(i, e)
二. 列表解析的使用方法
列表解析（list comprehension），又译为“列表推导”
>>>[i for i in range(100) if i%2 == 0]
[0, 2, 4, ……]
>>>a=[1, 2, 3, 4]
>>>b=[5,6,7,8]
>>>[x+y for x, y in zip(a, b)]
6, 8, 10, 12
'''
统计字符串中每个单词的数量
'''
song = 'when I am down and oh my soul so weary when troubles come and my heart burdened be Then I am still and wait here in the silence Until you come and sit awhile with me You raise me up so I can stand on mountains You raise me up to walk on stormy seas I am strong when I am on your shoulders You raise me up to more than I can be You raise me up so i can stand on mountains You raise me up to walk on stormy seas I am strong when Iram on your shoulders You raise me up to more than I can be You raise me up so I can stand on mountains'
slst=song.split()
d={}
for word in slst:
word = word.lower()
if word in d:
d[word]+=1
else:
d[word] = 1
print(d)
{'when': 4, 'i': 10, 'am': 5, 'down': 1, 'and': 4, 'oh': 1, 'my': 2, 'soul': 1, 'so': 4, 'weary': 1, 'troubles': 1, 'come': 2, 'heart': 1, 'burdened': 1, 'be': 3, 'then': 1, 'still': 1, 'wait': 1, 'here': 1, 'in': 1, 'the': 1, 'silence': 1, 'until': 1, 'you': 8, 'sit': 1, 'awhile': 1, 'with': 1, 'me': 8, 'raise': 7, 'up': 7, 'can': 5, 'stand': 3, 'on': 7, 'mountains': 3, 'to': 4, 'walk': 2, 'stormy': 2, 'seas': 2, 'strong': 2, 'your': 2, 'shoulders': 2, 'more': 2, 'than': 2, 'iram': 1}
字典解析
>>>d = {'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4}
>>>{v:k for k, v in d.items()}
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
'''
如下字典，将键和值对换，即键作为值，值作为键
d = {'book' : ['python', 'datascience'], 'author' : 'laoqi', 'publisher' : 'phei'}
'''
#方法1
d = {'book' : ['python', 'datascience'], 'author' : 'laoqi', 'publisher' : 'phei'}
dd={}
import collections.abc
for k,v in d.items():
if isinstance(v, collections.abc.Hashable):
dd[v]=k
else:
dd[tuple(v)]=k
print(dd)
{('python', 'datascience'): 'book', 'laoqi': 'author', 'phei': 'publisher'}
#方法2
d = {'book' : ['python', 'datascience'], 'author' : 'laoqi', 'publisher' : 'phei'}
import collections.abc
{v if isinstance(v,collections.abc.Hashable) else tuple(v) : k for k,v in d.items()}
集合解析
>>>alist = [1,2,3,50,89,26,30]
>>>{i for i in alist if i%2 == 1}
{1, 3, 89}
while循环
一. while循环语句
>>>a = 2
>>>while a>0:
a -= 1
print(a）
1 0
>>>x = 10
>>>while x>0:
if x % 2 ==1:
break #终止当前循环
else:
print(x)
x-=1
10
>>>while True:
n=input('input an int:')
print(n) (死循环，没有终止）
>>>while True:
n=input('input an int:')
n=int(n)
if n%2 == 0:
break
else:
print(n) #只打印奇数，遇到偶数就跳出循环
二. 循环中的else
>>>for i in range(4):
print(i)
else:
print('no break')
0 1 2 3 no break
>>>for i in range(4):
print(i)
break （非正常终止）
else:
print('break')
0
>>>lst = [1, 3, 5]
>>>for i in lst:
if i%2 == 0:
print('list contains an even number.')
break
else:
print('list does not contains an even number.') (此处若else作为if的分支，则输出三次）
'''
定义函数：用for和else找某个范围内的素数
'''
for n in range(2,100):
for i in range(2,n):
if n % i == 0:
print(n, '=', i, '*', n/i)
else:
print('n is a prime number.')
字典解析（补充）
一. 字典解析
基本语法
>>>my_nums={i : i for i in range(1:6)}
>>>print(my_nums)
{1:1, 2:2, 3:3, 4:4, 5:5}
包含条件
>>>nums = {str(i) : i for i in range(1, 6) if i%2 ==1}
>>>print(nums)
{'1' : 1, '3' : 3, '5' : 5}
>>>data = {'id' : 1, 'first_name' : 'Jonathan', 'middle_name' : None, 'last_name' : 'Hsu'}
>>>{k, v for (k, v) in data.items() if v !=None} #移除None
{'id': 1, 'name': 'laoqi'}
>>>data={'first_name' : 'Jonathan', 'last_name' : 'Hsu'}
>>>{k : v.upper() for (k, v) in data.items()} #将字典的值变为大写
{'first_name': 'JONATHAN', 'last_name': 'HSU'}
二. 合并字典的多种方法
基本方法：update()
>>>d1 = :'a' : 1, 'b' : 2}
>>>d2 = {'c' : 3. 'd' : 4}
>>>d3 = d1.copy()
>>>d3.update(d2)
>>>d3
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>>dd = {'a' : 111, 'd' : 4}
>>>d3 = {'a' : 1, 'b' :2, 'c' : 3, 'd' : 4}
>>>d3.update(dd)
>>>d3
{'a' : 111, 'b' :2, 'c' : 3, 'd' : 4} (同一个键的值最后一个有效）
解包方法 （支持多个字典同时合并）
>>>d1
{'a' : 1, 'b' :2}
>>>d2
{'c' : 3, 'd' : 4}
>>>d3 = {**d1, **d2}
>>>d3
{'a' : 1, 'b' :2, 'c' : 3, 'd' : 4}
使用dict(iterable, **kwarg) (这里也支持多个字典同时合并）
>>>d1
{'a' : 1, 'b' :2}
>>>d2
{'c' : 3, 'd' : 4}
>>>d3 = dict{d1, **d2}
>>>d3
{'a' : 1, 'b' :2, 'c' : 3, 'd' : 4}
异常处理
一. 错误和异常
错误
○ 逻辑错误
只能人为识别更改
○ 语法错误，又称解析错误
解析器会输出语法错误的行
异常
○ 内置异常
常见的内置异常举例：
NameError 尝试访问一个没有声明变量
ZeroDivisionError 除数（分母）为0
IndexError 索引超出序列范围
KeyError 请求一个不存在的字典的键
IOError 输入、输出错误
AttributeError 尝试访问未知的对象属性
二. 异常处理
异常处理语句：
用excel语句捕获异常
>>>try:
(do something)
except [tuple of Exception]:
(other thing)
while True:
try:
x = int(input('input an int:'))
r=10/x
print(r)
① except: #except后未写异常类型，表明try子句不论出现如何异常，都会被捕获
print('you should not input zaro.')
break
② except ZeroDivisionError: #用不同的分支捕获不同的异常类型，返回不同提示语
print('you should not input zero.')
break
except SyntaxError:
print('input a number.')
③ except (ZeroDivisionError, SyntaxError) as e: #用一个分支捕获多种异常
print(e)
break
其他结构：
只有在try子句没有异常时才会执行else子句，否则excel捕获异常 不执行else语句
>>>try:
(do something)
except [tuple of Exception]:
(other thing)
else:
(something)
>>>try:
print('hello')
except ValueError:
print('exception')
else:
print('try, else')
Hello
try, else
>>>try:
1/0
except ZeroDivisionError as e:
print(e)
else:
print('try, else')
division by zero
不论是否有异常，finally子句都会被执行
>>>try:
(do something)
except [tuple of Exception]:
(other thing)
else:
(something)
finally:
(something)
while True:
try:
x = int(input('input an int:'))
r=10/x
print(r)
except ZeroDivisionError as e:
print(e)
break
finally:
print('goodbye.')
break
input an int:0
integer division or modulo by zero
Goodbye
input an int:2w
goodbye
抛出异常：raise语句允许强制发生指定的异常
>>>raise NameError('python')
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
NameError: python
>>>try:
raise NameError('python')
except NameError:
print('exception')
raise
exception
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
NameError: python
断言：assert语句，发起条件判断
>>>x = -2
>>>assert x < 0
>>>assert x > 0
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
assert x > 0
AssertionError
while true
try:
age = int(input('How old are you?'))
assert age > 0
if age > 150:
raise ValueError('Are you a god?')
elif (age <= 150) and (age > 80):
print('Wish you good health.')
elif (age <= 80) and (age > 60):
print('Work hard.')
else:
print('I envy you.')
except ValueError:
print('find your glasses.')
break
How old are you?-23
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
assert age > 0
except (ValueError, AssertionError):
print('find your glasses.')
break
How old are you?-23
find your glasses.
“篇”
函数
一. 认识函数
Python内置函数：
自定义函数：
>>>deff add(x, y):
'''
This is an add function.
'''
r = x + y
return r #开头def后面的函数值等于return后面的返回值
>>>help(add) #查看帮助文档方法1
This is an add function.
>>>add.__doc__ #查看帮助文档方法2
'\n This is an add function.\n '
>>>add(3, 4)
7
>>>r = add(3,4)
>>>r
7
>>>def my_book():
return "Learn Python"
>>>my_book() (调用函数时即便没有参数也要带上小括号
'Learn Python'
>>>def book()：
print('Learn Python') （默认执行return None
>>>book()
Learn Python
>>>b = book()
Learn Python
>>>print(b)
None (没有return时，python解释器会默认返回一个值None
>>>def foo():
print('before return')
return
print('after return')
>>>foo()
before return
（当函数体中的程序遇到return时会中断函数，并把相应值返回调用位置
例题1 编写函数，查找某个范围内自然数中的素数
#方法1
import math
def is_prime1(n): #isPrime1
if n <= 1:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
#方法2
def is_prime2(n):
if n <= 1:
return False
i = 2
while i*i =<= n:
if n % i == 0:
return False
i += 1
return True
#方法3
from itertools import count
def is_prime3(n):
if n <= 1:
return False
for i in count(2):
if i * i >n:
return True
if n * i ==0:
return False
#方法4
def is_prime4(n):
if n <= 1:
return False
if n == 2:
return True
if n % 2 ==0:
return False
i = 3
while i * i <= n:
if n % I ==0:
return False
i += 2
return True
#方法5
def find_prime(nlst):
primes = []
for n in nlst:
for x in range(2, n):
if n % x == 0:
break
else:
primes.append(n)
return primes
#调用方法5
ns = range(2, 20)
print(find_prime(ns))
#调用方法4
primes_lst = [i for i in ns if is_prime4(i)]
print(primes_lst)
二. 调用函数
“传参数”的方式：按照位置、根据名称、设置默认值
>>>def foo(x, y):
print('x=', x)
print('y=', y)
return x+y
>>>foo(3, 4)
x=4
y=3
7
>>>foo(4, 3)
x=4
y=3
7
>>>foo(x=3, y=4)
x=3
y=4
7
>>>foo(y=4, x=3)
x=3
y=4
7
>>>def bar(x, y=3)
print('x=', x)
print('y=', y)
return x+y
>>>bar(2)
x=2
y=3
5
>>>bar(2, 6)
x=2
y=6
8
>>>bar(y=1, x=9)
x=9
y=1
10
参数与对象关系
传参数本质上是传递了函数外面对象的引用，参数只引用容器，容器本身没有变化
通常，不对函数的参数所引用对象类型进行检查
可以用pass关键词定义函数
函数名称代表函数对象
返回值和参数收集
一. 返回值
return语句中断函数执行，并将对象返回到函数调用位置；如果没有写return语句，则默认为return None; reurn可以返回一个对象，也可以返回多个对象
>>>def foo():
return 1, 2, 3
>>>a=foo()
>>>a
(1, 2, 3)
>>>b = 1, 2, 3
>>>b
(1, 2, 3)
>>>x, y, z = foo()
>>>x
1
>>>y
2
>>>z
3
>>>x, y, z = 1, 2, 3
>>>x
1
>>>y
2
>>>z
3
例题1 编写斐波那契数列函数
#方法1：
>>>def fibs(n):
result = [0, 1]
for i in range(n-2):
result.append(result[-2] + result[-1])
return result
lst = fibs(10)
print(lst)
#方法2：
>>>def fibs(n):
result = [0, 1]
[result.append(result[-1] + result[-2]) for i in range(n-2)]
return result
lst = fibs(10）
print(lst)
例题2 在0~100间随机取10000个整数，这些数组成一个列表。计算列表中所有数的平均数和标准差
import random
def mean(lst):
s = sum(lst)
n = len(lst)
return s / n
def standard_deviation(lst):
import math
mean = sum(lst)/len(lst)
for x in lst:
bias_mean = [(x - mean)**2] 注意要用列表去囊括
s2 = sum(bias_mean)/len(lst)
return math.sqrt(s2)
lst = [random.randint(0, 100) for i in range(10000)]
ave = mean(lst)
sta = standard_deviation(lst)
print('平均值是：', ave)
print('标准差是：', sta)
二. 参数的收集
星号“*”的作用
○ 参数：
-*args
-**kwargs
○ 变量：
-x, *y = 1, 2, 3, 4
>>>def foo(x, *args):
print('x=', x)
print('args=', args)
>>>foo(2, 3, 4, 5)
x = 2
args = (3, 4, 5) 会把剩下元素用元组取出来
>>>foo(2)
x = 2
args = ()
>>>foo(2,3)
x = 2
args = (3,) 注意元组里只有一个元素后面也要加逗号
>>>foo(2, [2, 3, 4])
x = 2
args = ([2, 3, 4],)
>>>def bar(**kwargs):
print('kwargs = ', kwargs)
>>>bar(2, 3, 4) × 两个星号不支持按位置取数，只支持按名称取数
>>>bar(a=1, b=2, c=3)
kwargs = {'a': 1, 'b': 2, 'c': 3} 按字典形式返回
>>>def foo(*args, **kwargs):
print('args=', args)
print('kwargs=', kwargs)
>>>foo(2, 'a', x=3, b=[1, 2, 3])
args = (2, 'a')
kwargs = {'x': 3, 'b': [1, 2, 3]}
>>>x, *y = 1, 2, 3, 4
>>>x
1
>>>y
[2, 3, 4]
>>>def bar(x, y, z):
print('x=', x)
print('y=', y)
print('z=', z)
>>>bar(1, 2, 3)
x =1
y = 2
z = 3
>>>t = (8, 9)
>>>bar(2, t, 22)
x = 2
y = (8, 9)
z = 22
>>>bar(2, *t)
x = 2
y = 8
z = 9
>>>bar(x = 2, *t)×
>>>bar(*t, x=2)×
>>>bar(*t, z =2) #效果等同于bar(*t, 2)
x = 2
y = 8
z = 9
>>>d = {'x': 1, 'y': 2, 'z': 3}
bar(d)×
>>>bar(**d) #等同于按照位置提供参数
x = 1
y = 2
z = 3
嵌套函数和装饰器
一. 函数是对象
再认识函数
○ 函数是对象
>>>def opt(func, iterable):
r = [func(i) for i in iterable]
return r
>>>lst = opt(abs, [-1, -2, -3] #作为对象的函数可以被另外一个函数的参数所引用
>>>lst
[-1, -2, -3]
二. 嵌套函数
返回函数
○ 将函数作为返回值
-返回内置函数对象
>>>def my_func(bf)
return bf
>>>mabs = my_func(abs)
>>>mabs
<built-in function abs>
>>>abs is mabs #等同于判断id(abs)==id(mabs)
True
>>>mabs(-3)
3
-返回自定义函数对象
>>>def add(x, y):return x+y
>>>madd = my_func(add)
>>>id(madd) = id(add)
True
嵌套函数
○ 一个函数体内定义另外一个函数
-内嵌的函数不会随着外层函数调用而被执行
-内嵌的函数不能在外层函数所在空间调用
-返回内嵌的函数对象
def foo(): #1
def bar():
print("I am in bar.")
print('I am in foo.')
foo()
I am in foo.
def foo(): #2
def bar():
print("I am in bar.")
print('I am in foo.')
bar()
foo()
I am in foo.
I am in bar.
def foo(): #3
def bar():
print("I am in bar.")
print('I am in foo.')
foo()
bar()
I am in foo.
<NameError: Name 'bar' is not defined> 超出作用域
def foo():
def bar():
print("I am in bar.")
print('I am in foo.')
return bar #可以用return语句把里面函数对象返回
b = foo()
b()
I am in foo.
I am in bar.
三. 变量作用域
变量作用域
○ 作用域指的是变量的有效范围
-函数内部的局部（本地）作用域
§ 嵌套函数内
§ 嵌套函数之外但在外层函数之内
-全局作用域
-内置作用域
○ 划分作用域
-根据代码结构划分不同级别的作用域：（块级）、函数、类、模块、包
-Python中，if语句块、for语句块、with上下文管理器等等不能划分变量作用域
-函数和类改变作用域:def, class, lambda
○ 搜索规则
§ 从内向外，逐层搜索，找到则停止
§ 作用域取决于代码块在整体代码中位置
-例如函数代码块的位置，而与函数调用的位置无关
○ 变量掩盖和修改
§ 如果在函数内部引用了一个和全局变量同名的变量，且不是重新赋值，那么函数内部引用的是全局变量
§ 如果函数内部重新赋值了一个和全局变量名称相同的变量，则这个变量是局部变量，它会掩盖全局变量
>>>x = 3
>>>def g():print(x)
>>>g()
3
>>>def g2():
x = 2
print(x)
>>>g2()
2
>>>x
3
○ 两个关键词
§ global：制定当前变量使用外部的全局变量
§ nonlocal：内层函数中的变量它外一层函数的变量
-global修饰的变量可能实现并未存在于全局作用域内，但nonlocal修饰的变量必须已经存在与外层函数，不能只存在于全局
>>>x = 1
>>>def foo():
x = 1
x +=2 相当于x = x+2，所以需先给局部作用域的x赋值
return x
>>>foo()
3
>>>x
1 不影响全局作用域里的x
>>>x = 1
>>>def foo():
global x
x += 2
return x
>>>foo()
3
>>>x
3 x也实现了自增
>>>def foo():
x = 4
def bar():
nonlocal x
x += 1
print(x)
return bar
>>>b = foo()
>>>b()
5
例题1：利用嵌套函数，编写实现“一元二次函数”的程序
def parabola(a, b, c):
def para(x):
return a*x*x + b*x + c
return para
y = parabola(2, 3, 4)
r = y(3)
print("y = 2x^2 + 3x + 4 |x=3, the result = {0}".format(r))
四. 简单的装饰器
简单装饰器
○ 从嵌套函数到语法糖@
○ 没有参数的装饰器
def book(name):
return name
def strong_deco(f):
def wrapper(name):
return '<string>{0}</strong>'.format(f(name))
return wrapper
my = strong_deco(book) #以第1行定义的函数为嵌套函数的参数
book = my('Learn Pthon') #以该字符串作为name对象的值
print(book)
（执行结果：<strong>Learn Python</strong>)
def strong_deco(f):
def wrapper(name):
return '<string>{0}</strong>'.format(f(name))
return wrapper
@strong_deco
def book(name): #使用上面的嵌套函数装饰这个函数（其实就是把下面的函数传给嵌套函数
return name
b = book('Learn Pthon') #直接调用book函数就能直接执行嵌套函数里所要执行的操作了
print(b)
（执行结果：<strong>Learn Python</strong>）
例题2：编写一个用于测试函数执行时间的装饰器
import time
def timing_func(func):
def wrapper():
start = time.time()
func()
stop = time.time()
return wrapper
@timing_func
def test_list_append():
lst = []
for i in range(0, 100000):
lst.append(i) #append法追加到列表
@timing_func
def test_list_compre():
[i for i in range(0, 100000)] #列表解析法
a = test_list_append()
c = test_list_compre()
print("test list append time:", a)
print("testt list comprehension time:", c)
print("append/compre:", round(a/c, 3))
特殊函数
一. lambda函数
>>>lam = lambda x, y: x + y #没有设置函数名称的函数对象，但可以用变量引用lambda函数对象
>>>type(lam)
<class 'function'>
>>>def add(x, y):
return x + y
>>>lam(2, 3)
5
>>>add(2, 3)
5
>>>n = range(-5, 5)
>>>[True if i>0 else False for i in n] #方法1
[False, False, False, False, False, False, True, True, True, True]
>>>[(lambda x:x>0)(i) for i in n] #方法2
[False, False, False, False, False, False, True, True, True, True]
二. map函数
>>>[i+1 for i in range(10)] #方法1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>>[(lambda x:x+1)(i) for i in range(10)] #方法2
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>>m = map(lambda x:x+1, range(10)) #方法3
>>>m
<map object at 0x10b9877f0>
>>>list(m)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>>a = [1, 2, 3]
>>>b = [4, 5, 6]
>>>[x+y for x, y in zip(a, b)] #方法1
[5, 6, 7]
>>>r = map(lambda x, y: x+y, a, b) #方法2
>>>list(r)
[5, 6, 7]
三. filter函数 filter(func or None, iterables) → filter object
>>>n = range(-5, 5)
>>>f = filter(lambda x: x>0, n) #方法1
>>>f
<filter object at 0x10b9878d0)
>>>list(f)
[1, 2, 3, 4]
>>>[i for i in n if i>0] #方法2
[1, 2, 3, 4]
海象运算符（针对3.8及以上版本）
一. 海象运算符
本质上是赋值语句，让程序更精炼
a := b
e.g 1:
count = fresh_fruit.get('lemon', 0)
if count:
make_leminade(cound)
else:
pass
if count := fresh_fruit.get('lemon', 0):
make_leminade(cound)
else:
pass
e.g 2:
Count = fresh_fruit.get('apple', 0)
if count >= 4:
make_cider(count)
else；
Pass
if (count := fresh_fruit.get('apple', 0)) >=4:
make_cider(count)
else；
Pass
二. 用海象运算符优化程序
books = {'python': 59, 'go': 69, 'java': 49, 'php': 39}
if (price := books.get("python", 0)) <= 50:
print(f"python价格: {price}")
elif (price := books.get("go", 0)):
print(f"GO价格: {price}")
elif (price := books.get("java", 0):
print(f"Java价格: {price})
else:
print("PHP啦")
**注意事项**
在单个表达式中同时对变量名进行赋值和计算，从而减少重复
当赋值表达式是一个较大表达式的子表达式时，必须用圆括号括起来
练习题
一. 三角形三条边的长度分别为3、7、9，计算这个三角形的三角度数（用弧度制表示）：
import math
a=3
b=7
c=9
C=math.acos((a**2+b**2-c**2)/(2*b*a))
print(c)
二. 对于字符串：'you need python',
分别得到三个单词：
a='you need python'
b=a.split()
print(b)
按照从左向右的顺序，隔一个字符取一个：
a='you need python'
a[::2]
按照从右向左的顺序，隔一个字符取一个：
a='you need python'
a[::-2]
将字符串反序：
a='you need python'
a[::-1]
三. 字符串' hello '的h左侧和0右侧都有空格，使用字符串的方法去除空格：
a=' hello '
a.strip()
将字符串'you need python'中的空格用'*'替代：
a='you need python' #方法1
'*'.join(a.split())
a='you need python' #方法2
a.replace(' ','*',-1)
四. 编写程序，实现以下操作，通过键盘输入数字，作为圆的半径，计算圆的周长和面积，并分别打印出来，结果保留两位小数:
import math
r = input('please input a number:')
r = float(r)
C = 2*math.pi*r
S = math.pi*r**2
print('the circle is:', round(C, 2))
print('the area is:', round(S, 2))
五. 编写程序，实现如下功能，询问用户姓名和年龄，计算十年后年龄，打印出用户姓名、年龄、十年后年龄：
name = input('请输入你的姓名：')
age = input('请输入你的年龄：')
after_age = int(age) + 10
print('-'*10)
print('你的姓名是{0}\n你现在是{1}岁\n十年后，你是{2}岁'.format(name, age, after_age))
一. 将字符串'python'转化为列表（记为lst），然后完成如下操作：
>>>s='python'
>>>lst=list(s)
>>>lst
['p','y','t','h','o','n']
将字符串'rust'中的每个字母作为独立元素追加到lst中
>>>r='rust'
>>>lst.extend(r) ('extend'是逐个添加，'append'是整个添加
>>>lst
[ ['p','y','t','h','o','n','r','u','s','t']
对lst排序
>>>lst.sort()
>>>lst
['h','n','o','p','r','s','t','t','u','y']
删除lst中的重复元素
>>>lst.index('t') #方法1：用pop
6
>>>lst.pop(6)
>>>lst
['h','n','o','p','r','s','t','u','y']
>>>s=set(lst) #方法2：利用集合的互异性
>>>s
{'h','n','o','p','r','s','t','u','y'}
>>>lst2=list(s)
>>>lst2
['h','n','o','p','r','s','t','u','y']
二. 编写程序，实现用户输入国家名称,打印出所输入国家名称及首都：
nations={'China':'Beijing','Japan':'Tokyo','India':'NewDelhi','Sweden':'Stockholm','Russian':'Moscow','Germany':'Berlin','UK':'London','French':'Paris'}
name=input('请输入国家名称：')
capital=nations.get(name)
print('您输入的国家是：',name)
print('它的首都是：',capital)
三. 有如下技术栈名称集合：skills={'Python','R',SQL','Git','Tableau','SAS'}。假设自己的技术是myskills={'Python','R'}，判断自己所掌握的技术是否在上述技术栈范围内
skills={'Python','R','SQL','Git','Tableau','SAS'}
myskills={'Python','R'}
myskills.issubset(skills) #方法1 bool(myskills&skills) #方法2
四. 找出以下两个字典共有的键：{'a':1,'b':2,'c':3,'d':4} {'b':22,'d':44,'e':55,'f':77}
d1={'a':1,'b':2,'c':3,'d':4} #方法1：转化为集合运算
d2={'b':22,'d':44,'e':55,'f':77}
d1_keys=set(d1.keys())
d2_keys=set(d2.keys())
d1_keys&d2_keys
d1={'a':1,'b':2,'c':3,'d':4} #方法2：用视图支持符号计算
d2={'b':22,'d':44,'e':55,'f':77}
d1.keys()&d2.keys()
五. 字符串：songs='You raise my up so I can stand on mountains You raise my up to walk on stormy seas I am strong when I am on your shoulders You raise me up to more than I can be'
制作上述字符串的单词表：
songs='You raise my up so I can stand on mountains You raise my up to walk on stormy seas I am strong when I am on your shoulders You raise me up to more than I can be'
songs_set=set(songs.split())
统计每个单词的出现次数：
songs.count('stand')
一. 判断用户的键盘输入内容：如果都是数字，则将该数字扩大十倍，然后打印显示；如果是字母，则在其后面增加“@python”后打印显示；其他情况则将输入内容按原样显示
n = input ('请输入内容：')
if n.isdigit():
print(float(n) * 10)
elif n.isalpha():
print(n+ '@python')
else:
print(n)
二. 有字符串：Life is short You need python， 显示每个单词大写和小写两种状态，统计每个单词的长度
a = 'Life is short You need python'
for word in a.split():
print(word, ':', word.lower(), word.upper(), len(word))
三. 写一个猜数游戏程序。计算机生成一个100以内的正整数，用户通过键盘输入数字，猜测所生成的随机数，对用户的输入次数不进行限制
import random
number = random.randint(0,100)
guess = 0
while True:
num = input('请输入一个0到100之间的数：')
guess += 1
if not num.isdigit():
print('你输入的不是数字')
elif int(num) <= 0 or int(num) >= 100:
print('输入的数字应该在0到100之间')
else:
if int(num) == number:
print('你猜对了，你用了{0}次'.format(guess))
break
elif int(num) < number:
print('你猜小了')
else:
print('你猜大了')
四. 找出列表[2, 4, -7, 19, -2, -1.45]小于零的数
lst = [2, 4, -7, 19, -2, -1.45]
[i for i in lst if i < 0]
某学生考试成绩：{'python':89, 'java':58, 'physics':65, 'math':49, 'Chinese':78}，找出各科目大于平均分的学科
scores = {'python': 89, 'java': 58, 'physics': 65, 'math': 49, 'Chinese': 78}
ave = sum(scores.values())/len(scores)
print({k : v for k, v in scores.items() if v > ave})
计算1到99（含）的整数平方的和
sum = 0
for i in range(1,100):
sum = i**2
print(i)
9801
一. 编写函数，对单词中的字母实现如下操作：根据参数设置，将单词中的字母转化为大写或者小写，返回转化之后的单词
def convert(word, low = True):
if low:
return word.lower()
else:
return word.upper()
w = "Physics"
print(convert(w))
print(convert(w, low = False))
physics
PHYSICS
二. 编写函数，计算平面直角坐标系中两点的距离，函数的参数是两点的坐标。
def distance(pa, pb):
import math
lst = [(x - y)**2 for x, y in zip(pa, pb)] #lst = map(lambda x, y: (x - y)**2, pa, pb))
d = math.sqrt(sum(lst))
return d
pa = (1, 2)
pb = (3, 4)
return('d=', distance(pa, pb))
编写函数，判断某字符串中是否含有指定集合中的字母。
def contain_any_1(seq, aset): #方法1：简单for循环
for c in seq:
if c in aset:
return True
return False
def contain_any_2(seq, aset): #方法2：filter函数与.__contains__
for item in filter(aset.__contains__, seq): #即查看set里的每一个元素是不是在aset中
return True
return False
def contain_any_3(seq, aset): #方法3：bool函数，判断seq与aset是否有交集
return bool(aset.intersection(seq)) #想到集合间的运算
seq = "apython"
aset = set(['a', 'b', 'c', 'd', 'e'])
result = contain_any_3(seq, aset)
print(result)
True
三. 在字典中有get方法，但是列表中没有。编写函数，对列表实现类似字典中get方法的功能
def get_by_index_1(lst, i, value = None): #方法1
if I < len(lst):
return lst[i]
else:
return value
def get_by_index_2(lst, i, value = None): #方法2(比方法1更鲁棒）
if -len(lst) <= i < len(lst):
return lst[i]
else：
return value
def get_by_index_3(lst, i, value = None): #方法3（更直接，且使用try，except）
try:
return lst[i]
except IndexError:
return value
lst = [1, 2, 3]
while True:
try:
idx = int(input('input index of list:'))
except ValueError:
print("Index should be int.")
continue
value = input('input value:')
if value != 'q':
r1 = get_by_index_1(lst, idx, value）
r2 = get_by_index_2(lst, idx, value)
r3 = get_by_index_3(lst, idx, value)
print(r1, r2, r3)
else:
break
执行:
input index of list:w #输入的是int所不能转换的
Index should be int.
input index of list:2 #2在索引范围内
input value:p #返回list[2]=3
3 3 3
input index of list:6 #6超出了列表索引范围
input value:w
W w w #所以返回输入的value值'w'
input index of list:1
input value:q #break退出
四. 假设有文件名：py10.py, py2.py, py1.py, py14.py，编写对文件名进行排序的函数
import re
def select_numbers(s):
pieces = re.compile(r'(\d+)').split(s) #表示以数字分割字符串，等同于re.split(r'(\d+)', 'py10.py')
pieces[1::2] = map(int, pieces[1::2])
return pieces
def sort_filename(filemane):
return sorted(filename, key = select_numbers) #用上面函数对象所得到的结果进行排序
files = ['py10.py', 'py2.py', 'py1.py', 'py14.py']
result = sort_filename(files)
print(files)
print(result)
执行：
['py10.py', 'py2.py', 'py1.py', 'py14.py']
*本文为本人网易云课堂《数据分析》微专业听课笔记，侵删
4046
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
