Python 函数的定义、文档注释、作用域、数据类型（字符串，列表，元祖，集合，字典）的运用及相关例子
函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段·。
好处为：
一可以把程序中相对独立的功能模块抽取出来，减少重读代码的编写；
二是将来可以以重复的使用这些功能模块。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数内容以冒号起始，且缩进。
文档注释
1 .
"""
实现功能
Parameters:
x-类型
Returns:
返回值的作用
"""-
2.
"""
实现功能
:param x:类型
:param y:类型
:return:返回值的作用
"""作用域
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
- L （Local） 局部作用域
- E （Enclosing） 闭包函数外的函数中
- G （Global） 全局作用域
B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。如果想改变搜索范围 可以使用global 和nonlocal 关键字。
# global variable # 在函数外面定义的a 全局变量 a=100 def foo(): # 函数内部的局部变量 离开foo函数变量a 无法访问 # local variable global a a=200 print(a) foo() print(a) 结果： a=200 a=200
例题
计算阶乘
""" 输入M和N 计算C（M,N） """ def f(x): y=1 for z in range (1,x+1): y *= z return y print(__name__) # 通过下面的if条件可以再导入模块不去执行下面的代码 if __import__=='__main__': m=int(input('m=')) n=int(input('n=')) #当要计算阶乘的时候不用在写循环，而是直接调用已经写好的函数 print(f(m)) print(f(m)//f(n)//f(m-n)) 结果： m=5 n=3 120 10
计算输入两个数的最大公约数与最小公倍数
# 计算最大公约数
def gcd(x,y):
"""
计算最大公约数
:param x:一个正整数
:param y:一个正整数
:return:x,y的最大公约数
"""
(x,y)=(y,x) if x>y else (x,y)
for factor in range(x, 0, -1): #使用range的时候，可使用负数步长，前面加上-即可
if x % factor == 0 and y % factor == 0:
return factor
def lcm(x,y):
"""
计算最小公倍数
Parameters:
x-正整数
y-正整数
Returns:
x和y的最小公倍数
"""
return x*y//gcd(x,y)
print(gcd(25,5))
print(lcm(25,5))
结果：
5
25判断素数
from math import sqrt def is_prime(num): for rea in range(2,int(sqrt(num)+1)): if num%rea==0: return False return True if num !=1 else False print(is_prime(5)) 结果： True
字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号(‘或”)来创建字符串。
def main():
str1 = 'hello,world'
print(len(str1))#计算字符串的长度
print(str1.capitalize())#将字符串的第一个字符转换为大写
print(str1.upper())
print(str1)
print(str1.find('or'))
print(str1.find('shit'))
print(str1.index('or'))
print(str1.startswith('He'))
print(str1.endswith('!'))# 检查字符串是否以‘！’结束，如果是则返回True，不是则返回False
print(str1.center(50,'*'))#返回一个指定的宽度50居中的字符串，‘*’填充的字符
print(str1.rjust(50,' '))
str2='abc123456'
print(str2[2])
print(str2[2:5])
print(str2[2:])
print(str2[:])
print(str2[::2])
print(str2[::-1])
print(str2[-1:-3:-1])
print(str2[-3:-1])
print(str2.isdigit())
print(str2.isalpha())
print(str2.isalnum())
str3=' [email protected]'
print(str3)
print(str3.strip())
if __name__ == '__main__':
main()
结果:
11
Hello,world
HELLO,WORLD
hello,world
7
-1
False
False
*******************hello,world********************
hello,world
c
c12
c123456
abc123456
ac246
654321cba
65
45
False
False
True
jackfrued@126.com
jackfrued@126.com列表
1. 列表
是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
def main():
f=[100,200,500]
for index, val in enumerate(f):
print(index,':',val)
# CRUB Creat Read Update Dlete
f.append(123)
print(f)
f.insert(1,300)
print(f)
if 500 in f:#不确定元素存不存在
f.remove(500)#知道有这个元素
del f[3]#知道元素的位置
print(f.index(100))
print(f.pop())
print(f)
list1=[x for x in range (1,10)]
list2=list1
print(list2)
print(id(list1))
print(id(list2))
list2=list1[:]
print(id(list1))
print(id(list2))
print(list2)
list1[1]=1000
list2[0]=200
print(list1)
print(list2)
if __name__ == '__main__':
main ()
结果：
0 : 100
1 : 200
2 : 500
[100, 200, 500, 123]
[100, 300, 200, 500, 123]
0
200
[100, 300]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
39073288
39073288
39073288
39047432
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 1000, 3, 4, 5, 6, 7, 8, 9]
[200, 2, 3, 4, 5, 6, 7, 8, 9]
2.列表容器
# 用列表生成表达式语法创建列表容器
# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
f=list(range(1,10))#f=[x for x in range(1,10)]
e=[x ** 2 for x in range(1,10)]
g=[x ** x for x in range (1,10)]
print(f)
print(e)
print(g)
结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489]3.列表生成器
列表生成器 这里得到的不是一个列表，而是一个生成器对象
通过生成器可以获取数据 它不占用额外的存储空间
每次需要数据的时候就通过生成器取数据 当然这需要花费时间
f = (x ** x for x in range(1, 10))
print(sys.getsizeof(f))
print(f)
for val in f:
print(val,end=' ')
结果：
88
. at 0x0000000002548468>
1 4 27 256 3125 46656 823543 16777216 387420489 4. 列表的排序问题
在列表中可以对列表中的元素进行排序
def main():
f=['orange','zoo','apple','internationalization','blueberry']
#python 内置的排序方式默认为升序（从小到大）
#如果想要降序 用reverse参数来制定
#python中的函数几乎没有副作用的函数
#调用函数之后不会影响传入的参数
f2 = sorted (f,reverse=True)
print(f)
print(f2)
f.reverse()
f3=(reversed(f))
print(f3)
f4=sorted(f,key=str_len,reverse=True)
print(f4)
结果：
['orange', 'zoo', 'apple', 'internationalization', 'blueberry']
['zoo', 'orange', 'internationalization', 'blueberry', 'apple']
0x000000000259E9B0>
['internationalization', 'blueberry', 'orange', 'apple', 'zoo'] 如：fibonacci函数
def fib1(n):
d=[1,1]
for num in range (2,n):
val=d[num-1]+d[num-2]
d.append(val)
print(d)
print(d[::2])
print(d[-1:-3:-1])
d.reverse()
print(d)
if __name__ == '__main__':
fib1(20)
结果：
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
[1, 2, 5, 13, 34, 89, 233, 610, 1597, 4181]
[6765, 4181]
[6765, 4181, 2584, 1597, 987, 610, 377, 233, 144, 89, 55, 34, 21, 13, 8, 5, 3, 2, 1, 1]元祖
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
def main():
tup2 = (1, 2, 3, 4, 5 )
print ("tup2[1:5]: ", tup2[1:5])
结果：
tup2[1:5]: (2, 3, 4, 5)元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
tup1 = (50)
type(tup1) # 不加逗号，类型为整型
<class 'int'>
tup1 = (50,)
type(tup1) # 加上逗号，类型为元组
<class 'tuple'>元组中的元素值是不允许删除的.
集合
集合使用花括号将元素之间用逗号隔开即可。集合的输出里不会出现相同的元素。集合中有并集、交集、差集等，以下为一些简单的表达：
def main():
list1=[1,1,2,2,3,3]
print(list1)
set1={1,1,2,2,3,3}
print(set1)
set1.add(4)
set1.add(5)
print(set1)
set2={1,3,5,7,9}
print(set2)
set3=set1 & set2
#set3=set1.intersection(set2)
print(set3)
set3=set1 | set2
#st3=set1.union(set2)
print(set3)
set3=set1-set2
#set3=set1.difference(set2)
print(set3)
set3 = set2.difference(set1)
print(set3)
set3=set1 ^ set2
#set3=set1.symmetric_difference(set2)
print(set3)
for val in set2:
print(val)
print(set2.pop())
if 3 in set2:
set2.remove(3)
print(set2)
print(set2<=set1)
#print(set2.issubset(set1))
print(set1>=set2)
#print(set1.issuperset(set2))
if __name__ == '__main__':
main()
结果：
[1, 1, 2, 2, 3, 3]
{1, 2, 3}
{1, 2, 3, 4, 5}
{1, 3, 5, 7, 9}
{1, 3, 5}
{1, 2, 3, 4, 5, 7, 9}
{2, 4}
{9, 7}
{2, 4, 7, 9}
1
3
5
7
9
1
{5, 7, 9}
False
False集合，列表，元组间的相互装换
在python中列表，元祖，集合间可以进行相互转化，
def main():
set1={'hello','good','banana','zoo','Python','hello'}
print(len(set1))
x=sorted(set1)
print(type(x))
print(x)
list1=list(set1)
print(list1)
list2=[1,2,3,1,2,4]
set2=set(list2)
print(set2)
tuple1=(1,1,2,3,4,4)
list3=list(tuple1)
print(list3)
set3=set(tuple1)
print(set3)
if __name__ == '__main__':
main()
结果：
5
<class 'list'>
['Python', 'banana', 'good', 'hello', 'zoo']
['banana', 'hello', 'zoo', 'good', 'Python']
{1, 2, 3, 4}
[1, 1, 2, 3, 4, 4]
{1, 2, 3, 4}字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。
def main():
dict1={'name':'骆昊','age':38,'gender':True}
print(dict1['name'])
print(dict1['age'])
print(dict1['gender'])
dict1['name']='王大锤'
print(dict1)
dict1.update(height=170.5,fav=['吃','喝'])
print(dict1.pop('age'))
print(dict1.popitem())
print(dict1)
for x in dict1:
print(x,'-->',dict1[x])
dict.setdefault('motto','成年人的世界没有容易二字')
if 'motto' in dict1:
print(dict1['motto'])
else:
print('呵呵')
del dict1['motto']
print(dict1['motto'])
if __name__ == '__main__':
main()\
结果：
骆昊
Traceback (most recent call last):
38
True
{'name': '王大锤', 'age': 38, 'gender': True}
main()
38
('fav', ['吃', '喝'])
{'name': '王大锤', 'gender': True, 'height': 170.5}
name --> 王大锤
gender --> True
height --> 170.5
成年人的世界没有容易二字
print(dict1['motto'])
KeyError: 'motto'
综合题
1. 判断回文素数
from math import sqrt
number=int(input('请输入一个整数：'))
def is_prime(num):
for rea in range(2,int(sqrt(num)+1)):
if num%rea==0:
return False
return True if num !=1 else False
def is_palindrome(num):
temp=num
total=0
while temp>0:
total=total * 10+temp % 10
temp//=10
return num==total
if is_palindrome(number) and is_prime(number) :
print('%d是回文素数：' % number)
else:
print('%d不是回文素数：' % number)
结果：
请输入一个整数：56465
56465不是回文素数：2. 21根火柴游戏
"""
21跟火柴
"""
from random import randint
def main():
total=21
while total>0:
print('剩余%d跟火柴'% total)
while True:
num=int(input('你拿几根火柴：'))
if 1<=num<=4 and num<=total:
break
total-=num
if total>0:
com=randint(1,min(4,total))
print('计算机拿走了%d跟火柴' % com)
total-=com
if total==0:
print('计算机拿走了最后一根火柴你输了！')
else:
print('你拿走了最后一根火柴你输了！')
if __name__ == '__main__':
main()
结果：
剩余21跟火柴
你拿几根火柴：1
计算机拿走了3跟火柴
剩余17跟火柴
你拿几根火柴：4
计算机拿走了3跟火柴
剩余10跟火柴
你拿几根火柴：4
计算机拿走了4跟火柴
剩余2跟火柴
你拿几根火柴：1
计算机拿走了1跟火柴
计算机拿走了最后一根火柴计算机输了！3.猜数字游戏
import random
def main():
answer = random.randint(1, 100)
counter = 0
while True:
counter += 1
number = int(input('请输入: '))
if number < answer:
print('大一点')
elif number > answer:
print('小一点')
else:
print('恭喜你猜对了!')
break
print('你总共猜了%d次' % counter)
if counter > 7:
print('你的智商余额明显不足')
if __name__=='__main__':
main()
结果：
请输入: 50
大一点
请输入: 75
大一点
请输入: 88
小一点
请输入: 80
大一点
请输入: 85
大一点
请输入: 87
恭喜你猜对了!
你总共猜了6次4. 输出验证码
from random import randint
def generate_code (code_len):
"""
生成确定位数的验证码
:param code_len: 验证码长度
:return: 由大小写英文字母和数字构成的随机验证码
"""
all_chars='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
last_pos=len(all_chars)-1
code=''
for _ in range(code_len):
index=randint(0,last_pos)
code+=all_chars[index]
return code
if __name__ == '__main__':
print(generate_code(4))
结果：
WL9B5. 获取文件后缀名
def get_suffix(filename,has_dot=False):
"""
获取文件后缀名
:param filename: 文件名
:param has_dot: 后缀名是否带.
:return: 文件后缀名
"""
pos=filename.rfind('.')
if 01:
index=pos if has_dot else pos+1
return filename[index:]
else:
return ''
if __name__ == '__main__':
print(get_suffix('hello.jpg'))
print(get_suffix('abc.',True))
print(get_suffix('a.'))
print(get_suffix('hello.c',True))
print(get_suffix('adc.abc'))
结果：
jpg
.c
abc 6. 跑马灯
import os
import time
def main():
str1='欢迎来到前锋学习Python'
while True:
os.system('cls')
print(str1)
time.sleep(0.5)
str1=str1[1:]+str1[0]
if __name__ == '__main__':
main()
结果：
欢迎来到前锋学习Python
迎来到前锋学习Python欢
来到前锋学习Python欢迎
到前锋学习Python欢迎来
。。。。7. n颗骰子的和出现的次数
from random import randint
def roll_dice(n):
total=0
for _ in range (n):
num=randint(1,6)
total+=num
return total
#有了列表容器我们可以使用一个变量来保存多个数据
#更为重要的是我们可以使用循环对列表中保存的数据进行操作
def main():
f=[0]*11
for _ in range (60000):
face=roll_dice(2)
f[face-2]+=1
for index in range (len(f)):
print('%d摇出了%d次'% (index+2,f[index]))
#直接通过对for_in循环对容器进行便利
for counter in f:
print(counter)
if __name__ == '__main__':
main()
结果：
2摇出了1687次
3摇出了3391次
4摇出了5040次
5摇出了6668次
6摇出了8329次
7摇出了10095次
8摇出了8325次
9摇出了6603次
10摇出了4986次
11摇出了3239次
12摇出了1637次
1687
3391
5040
6668
8329
10095
8325
6603
4986
3239
16377. 一组数的最大值，最小值，平均数
def foo(n):
c=[]
for _ in range (n):
var=randint(60,100)
c.append(var)
print(c)
total=0
max = c[0]
min=c[0]
for i in range (1,n):
total += c[i]
if c[i]>=max:
max=c[i]
elif c[i]<=min:
min=c[i]
return max,min,total/9
if __name__ == '__main__':
print(foo(8))
结果：
[92, 88, 76, 76, 75, 92, 72, 84]
(92, 72, 62.55555555555556)8. 输出第二大的数
def second_max(x):
(m1,m2)=(x[0],x[1]) if x[0]>x[1] else (x[1],x[0])
for index in range (2,len(x)):
if x[index]>m1:
m2=m1
m1=x[index]
elif x[index]>m2 and x[index]!=m1:
m2=x[index]
return m1,m2
if __name__ == '__main__':
my_list=[85,96,56,98,88,98]
print(second_max(my_list))9. 彩票随机码的输出
"""
双色球-6个红色球（1-33）和一个蓝色球（1-16）
"""
from random import randint
def select(n):
red_balls=[x for x in range(1,34)]
select_bolls=[]
for _ in range(6):
index = randint(0,len(red_balls))
select_bolls.append(red_balls[index])
del red_balls[index]
select_bolls.sort()
num=randint(0,16)
select_bolls.append(num)
return select_bolls
def dis_play(balls):
for index,ball in enumerate(balls):
if index==len(balls)-1:
print('|',end=' ')
print('%02d' % ball,end=' ')
print()
def main():
n=int(input('机选几注：'))
for _ in range(n):
dis_play(select(n))
if __name__ == '__main__':
main()
10. 输入分数 输出最高分数对应的名字
def main():
names = ['刘备', '张飞', '曹操', '袁绍', '关羽', '赵云', '周瑜']
scores=[]
num=0
m=0
for name in names:
score = input('请输入%s的成绩: ' % name)
scores.append(score)
min_score, max_score = scores[0], scores[0]
for i in range(1,len(scores)):
if scores[i] > max_score:
max_score = scores[i]
num=max_score
m=scores.index(max_score)
print('最高分:', max_score)
print('%s' % names[m])
del names[m]
del scores[m]
print(names)
print(scores)
for i in range(1, len(scores)):
if scores[i]==num:
print ('%s'% names[i])
if __name__ == '__main__':
main()
结果：
请输入刘备的成绩: 88
请输入张飞的成绩: 78
请输入曹操的成绩: 85
请输入袁绍的成绩: 84
请输入关羽的成绩: 90
请输入赵云的成绩: 84
请输入周瑜的成绩: 90
最高分: 90
关羽
['刘备', '张飞', '曹操', '袁绍', '赵云', '周瑜']
['88', '78', '85', '84', '84', '90']
周瑜11. 表格式输出一组数据
def main():
names=['关羽','张飞','赵云','马超','貂蝉']
subjects=['语文','数学','Python']
table=[[0 for _ in range(3)] for _ in range(5)]
#table=[[0]*len(subjects)]*len(names)这种写法为错误的 为同一引用 同一地址
#table[[0]*len(subjects) for_ in range (5)]这种写法为正确的
for row,name in enumerate(names):
print('请输入%s的成绩：'% name)
for col,subject in enumerate (subjects):
table[row][col]=int(input('%s:' % subject))
print(table)
if __name__ == '__main__':
main()
结果：
请输入关羽的成绩：
语文:89
数学:88
Python:88
请输入张飞的成绩：
语文:78
数学:74
Python:75
请输入赵云的成绩：
语文:85
数学:96
Python:98
请输入马超的成绩：
语文:78
数学:85
Python:95
请输入貂蝉的成绩：
语文:55
数学:58
Python:95
[[89, 88, 88], [78, 74, 75], [85, 96, 98], [78, 85, 95], [55, 58, 95]]12. 传入年月日 输出为一年的第几天
def leap_year(year):
return (year//4==0 and year//100!=0) or (year //400==0)
def which_day(year,month,day):
total=0
days_of_month=[31,28,31,30,31,30,31,31,30,31,30,31]
for index in range (month-1):
total += days_of_month[index]
if month >2 and leap_year(year):
total += 1
return total + day
if __name__ == '__main__':
print(which_day(1980,11,28))
结果：
33213. 应用题
“"""
30个人出海去玩,船瓦特了,要弄死15个人,其他人才能活下来,围成一圈,报数1,2,3...,谁报到9就弄死谁,以此类推. 直到剩下15个人为止.其中15个人是基督徒,其他15个不是基督徒,求这些人的站位.
"""
def main():
persons=[True]*30
counter=0
index=0
number=0
while counter<15:
if persons[index]:
number += 1
if number==9:
persons[index]=False
counter += 1
number=0
index += 1
index %= 30
for person in persons:
print('基'if person else '非',end='')
if __name__ == '__main__':
main()
结果：
基基基基非非非非非基基非基基基非基非非基基非非非基非非基基非14. 给出行数，输出相应的杨辉三角
def main():
num = int(input('Number of rows: '))
yh = [[]] * num
for row in range(num):
yh[row] = [None] * (row + 1)
for col in range(row+1):
if col == 0 or col == row:
yh[row][col] = 1
else:
yh[row][col] = yh[row - 1][col] + yh[row - 1][col - 1]
print(yh[row][col], end='\t')
print()
if __name__ == '__main__':
main()
结果：
Number of rows: 5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1