Python基础语法

文章目录

    • 布尔
    • 列表
    • 元组
    • 字典
    • 集合
    • 浅拷贝和深拷贝
  • “句”
    • 逻辑运算
    • 条件语句
    • for循环
    • while循环
    • 字典解析(补充)
    • 异常处理
  • “篇”
    • 函数
    • 返回值和参数收集
    • 嵌套函数和装饰器
    • 特殊函数
    • 海象运算符(针对3.8及以上版本)
  • 练习题


布尔

一. 布尔类型
布尔类型的两个值: -True     -False
内置函数:bool
>>>True
True
>>>False
False
>>>type(True)

>>>'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)

>>>()
()
>>>tuple()
()
bool(tuple())
False
>>>tuple('python')
('p', 'y', 't', 'h', 'o', 'n')
>>>(3,)
(3,)
>>>type(('hello'))

>>>type(('hello',))      #只有一个元素的元组需要在元素后面加逗号

>>>[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)


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)

>>>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

>>>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 "", line 1, in 
NameError: python

>>>try:
        raise NameError('python')
   except NameError:
        print('exception')
        raise
exception
Traceback(most recent call last):
File "", line 1, in 
NameError: python
断言:assert语句,发起条件判断
>>>x = -2
>>>assert x < 0
>>>assert x > 0
Traceback(most recent call last):
  File "", line 1, in 
    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 "", line 1, in 
    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
	
	>>>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.
	     超出作用域
	
	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 '{0}'.format(f(name))
    return wrapper

my = strong_deco(book)      #以第1行定义的函数为嵌套函数的参数
book = my('Learn Pthon')     #以该字符串作为name对象的值
print(book)
(执行结果:Learn Python)

def strong_deco(f):
    def wrapper(name):
        return '{0}'.format(f(name))
    return wrapper

@strong_deco
def book(name):      #使用上面的嵌套函数装饰这个函数(其实就是把下面的函数传给嵌套函数
    return name

b = book('Learn Pthon')       #直接调用book函数就能直接执行嵌套函数里所要执行的操作了
print(b)
(执行结果:Learn Python)

例题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)

>>>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

>>>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
>>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']

*本文为本人网易云课堂《数据分析》微专业听课笔记,侵删

你可能感兴趣的:(python)