Python 快速入门学习

最新推荐文章于 2024-07-19 16:36:18 发布

Groot。

最新推荐文章于 2024-07-19 16:36:18 发布

阅读量603

点赞数

文章标签： python

本文链接：https://blog.csdn.net/weixin_46642516/article/details/115520614

版权

Python 快速入门学习

python的基本语法

1.1 变量

1.12 如何定义变量

1.13 输出一个变量

1.14 变量的数据类型

1.15 变量的运算

1.16 变量的输入

1.17 变量的类型转换

1.18 变量的格式化输出

逻辑判断（分支结构）

2.1 单个分支结构

2.2 多个分支结构

2.3 逻辑运算符

2.31 and 用法

2.32 or 用法

2.33 not 用法

2.4 逻辑嵌套

循环

3.1 循环的定义

3.2 while 循环的语法

3.21 while 循环实现累加

3.22 while 里面的 break 用法

3.23 while 里面的 continue 用法

3.3 循环嵌套

容器

4.1 字符串

4.11 字符串的概念

4.12 字符串通过下标访问对应的元素

4.13 字符串的遍历

4.14 字符串的常用API

4.141 字符串的替换

4.142 字符串的查找

4.143 字符串的切片

扩展判断字符串是否是数字

扩展判断字符串是否为字母

4.2 列表

4.21 列表和数组的区别

4.22 列表添加元素

4.23 列表删除元素

4.24 列表查找元素的下标

4.25 列表修改元素

4.26 列表的排序

元组

5.11 元组的定义

5.12 元组的应用

5.13 元组不支持增，删，改

5.14 元组的遍历

5.15 元组的查询

字典

6.1 字典的概念

6.2 字典的定义

6.3 字典添加元素

6.4 字典的元素修改

6.5 字典的查询

6.6 字典的遍历

6.61 取所有的键和值

6.62 取所有的键

6.63 取所有的值

6.64 嵌套字典

函数

7.1 函数的概念

7.2 函数的作用

7.4 函数的定义

7.5 函数的调用

7.6 函数的参数

7.61 单个参数

7.62 多个参数

7.63 参数的总结

7.7 函数的返回值 return

7.71 单个返回值

7.72 多个返回值

扩展函数与返回值的应用场景

7.8 函数中的默认参数

7.9 函数的关键字参数

7.10 函数的可变参数

7.11 成员变量和局部变量

7.12 成员变量（全局变量）

7.13 局部变量

7.14 申明成员变量（全局变量）

python的基本语法

1.1 变量

变量：内存中存储空间的一个表示

1.12 如何定义变量

例如：

a = 5

b = “你好”

1.13 输出一个变量

print(a)

print(b)

\t表示缩进，相当于按Tab的效果（4个空格）,\n表示换行

1.14 变量的数据类型

整数 int

浮点型 float

字符串 str 字符串可以使用单引号，双引号，3个双引号定义

布尔 bool

=表示赋值，==表示判断是否相等

例如：

a = 5 #整形

b = “你好” #字符串

c = 5.20 #浮点型

d = True #布尔类型

print(“a的数据类型是：”,type(a))

print(“b的数据类型是：”,type(b))

print(“c的数据类型是：”,type©)

print(“d的数据类型是：”,type(d))

1.15 变量的运算

1，字符串可以和字符串做加法运算

s1 = “12”

s2 = “3”

s = s1 + s2

print(“结果是：”,s)

#结果是：123

2，字符串可以和整形做乘法运算

s = “好好学习\t”

n = 10

jieguo = s * n

print("结果是："jieguo)

#结果是：好好学习好好学习好好学习好好学习好好学习好好学习好好学习好好学习好好学习好好学习

3，数值型可以和数值型做所有的算数运算

n1 = 7

n2 = 3

j1 = n1 + n2

j2 = n1 - n2

j3 = n1 * n2

j4 = n1 / n2

j5 = n1 % n2

j6 = n1 // n2

j7 = n1 ** n2

print(“n1和n2相加的结果为：”,j1)

print(“n1和n2相减的结果为：”,j2)

print(“n1和n2相乘的结果为：”,j3)

print(“n1和n2相除的结果为：”,j4)

print(“n1和n2求余数的结果为：”,j5)

print(“n1和n2取整结果为：”,j6)

print(“n1和n2求幂的结果为：”,j7)

#结果：

n1和n2相加的结果为： 10

n1和n2相减的结果为： 4

n1和n2相乘的结果为： 21

n1和n2相除的结果为： 2.3333333333333335

n1和n2求余数的结果为： 1

n1和n2取整结果为： 2

n1和n2求幂的结果为： 343

1.16 变量的输入

s = input(“请在控制台输入一个东西：”)

print(type(s)) #不管输入的什么类型，默认都是字符串类型

print(“输入的这个变量是：”,s)

1.17 变量的类型转换

n = int(str) #将字符串类型转换为整数类型

f = float(str) #将字符串类型转换为小数类型

实现一个2个数的加法计算器

n1 = input(“请输入第一个数：”)

n2 = input(“请输入第二个数：”)

print(‘n1的类型是：’,type(n1))

num1 = int(n1) #将n1转换为整形

num2 = int(n2)

print(‘num1的类型是：’,type(num1))

result = num1 + num2 print(“相加的结果为：”,result)

例如：

小明去超市购物：价格如下：口罩：3.5一个荔枝：12元一斤猪肉：26元一斤小明购买了3个口罩，2斤荔枝，半斤猪肉。

结账的时候，老板宣布所有商品全部打8折。请编写程序计算最终的应付款 :

kouzhao = 3.5 #定义一个口罩，单价是3.5一个

lizhi = 12 #定义荔枝，12元一斤

zhurou = 26 #定义猪肉，26一斤

money = kouzhao * 3 + lizhi * 2 + zhurou * 0.5

print(“应付金额为：”,money)

shiji = money * 0.8 print(“实际应付金额为：”,shiji)

1.18 变量的格式化输出

%s 表示字符串

%d表示整形

%f 表示小数

%s格式化输出

s = “我的名字叫%s,今天：%d岁，身高%.2f” % (name,age,height)

例如：# 1,定义姓名，年龄，身高这3个变量，采用格式化输出这样一句话“我的名字叫xx，今年xx岁，有xx米高”

xx为变量值

#%s格式化输出

s = “我的名字叫%s,今天：%d岁，身高%.2f” % (name,age,height)

#format格式化输出

s = “我的名字叫{},今天：{}岁，身高{:.1f}”.format(name,age,height)

#format格式化输出

s = “我的名字叫{},今天：{}岁，身高{:.1f}”.format(name,age,height)

逻辑判断（分支结构）

2.1 单个分支结构

if 表示如果

else 表示否则

例如：如果分数超过60分，那么就及格了，如果分数低于60分，那么就不及格

score = int(input(“请输入你的成绩：”))

if score >= 60:

print("及格")

else:

print("不及格")

2.2 多个分支结构

elif 表示不满足if里面的条件的前提下判断是否满足当前这个条件

例如：如果分数超过60分，那么就及格了，如果分数低于60分，如果分数超过80分，输出优秀，那么就不及

格

score = int(input(“请输入你的成绩：”))

if score >= 80:

print("优秀")

elif score >= 60: #只有当分数低于80分的时候，程序才会判断这个条件

print("及格")

else:

print("不及格")

2.3 逻辑运算符

and 表示并且

or 表示或者

not/！表示取反

2.31 and 用法

例如：如果语法成绩和数学成绩全部大于60分，输出批准毕业，如果有一门低于60分，都输出不能毕业

yuwen = int(input(“请输入语文成绩：”))

shuxue = int(input(“请输入数学成绩：”))

if yuwen >= 60 and shuxue >= 60:

print("可以毕业")

else:

print("不能毕业")

2.32 or 用法

例如：如果语文和数学有一门是满分，就可以毕业，否则就不能毕业

yuwen = int(input(“请输入语文成绩：”))

shuxue = int(input(“请输入数学成绩：”))

if yuwen == 100 or shuxue == 100:

print("可以毕业")

else:

print("不能毕业")

2.33 not 用法

例如：如果语文成绩不低于60分或者数学成绩不低于60分就可以毕业

yuwen = int(input(“请输入语文成绩：”))

shuxue = int(input(“请输入数学成绩：”))

if not(yuwen < 60) or not(shuxue < 60):

print("可以毕业")

else:

print("不能毕业")

2.4 逻辑嵌套

在if的里面或者在else的里面继续判断

例如：

username = input(“请输入用户名：”)

password = input(“请输入密码：”)

if username == “admin”:#表示用户名输入正确

	if password == "123": 

			print("登录成功") 

	else:

			print("密码错误")

else:#表示用户名输入错误

	if password == "123": 

			print("用户名错误，密码正确") 

	else:

			print("用户名和密码都错误")

例2：逻辑判断练习题：

小明去超市购物：

价格如下：口罩：3.5一个荔枝：12元一斤猪肉：26元一斤

小明购买了x个口罩，y斤荔枝，z斤猪肉。结账的时候，老板说有会员的用户如果商品金额大于200元打

六折，金额不足200元也可以打8折。没有会员的用户，金额大于200块，打9折，不足200块，不打折原

价支付。

程序：

输入：是否是会员，购买金额

输出：最终的实际支付金额

n1 = int(input(“口罩要几个：”))

n2 = float(input(“荔枝来几斤：”))

n3 = float(input(“猪肉来几斤：”))

kouzhao = 3.5 #定义一个口罩，单价是3.5一个

lizhi = 12 #定义荔枝，12元一斤

zhurou = 26 #定义猪肉，26一斤

money = kouzhao * n1 + lizhi * n2 + zhurou * n3

print(“购物金额是：{}元”.format(money))

vip = input(“请问是会员吗？（Y/N）”)

if vip == “Y”: #是会员

	if money >= 200: 

			m = money * 0.6   #是会员并且购买金额超过200  打6折

	else:

			m = money * 0.8   #是会员并且购买金额不超过200  打8折

else: #不是会员

	if money >= 200: 

			m = money * 0.9

print(“实际付款{}元”.format(m))

循环

3.1 循环的定义

重复的去执行一行或者多行代码

3.2 while 循环的语法

i = 1

while i < 5:

 print("好好学习") 

 i = i+1 #加法的运算优先级高于=号，所以i = i + 1，先将i+1的值赋值给i本身

print(“结束了”)

#结果：

好好学习

结束了

3.21 while 循环实现累加

在while循环的里面放多行代码

i = 6

#再定义一个变量，这个变量的作用就是存钱罐（容器）

sum = 0

while i <= 13:

	sum = sum + i 

	i += 1

print(“整数之和为：{}”.format(sum))

#结果：

整数之和为：76

例2：

假设黄金的日涨幅为0.8%（只涨不跌），现在买了1万块的黄金，问经过多少天，本金可以变成10万。

day = 0

money = 10000

while money <= 100000:

	money = money * 0.008 + money 

	day += 1

print(“需要{}天，达到10万”.format(day))

#结果：

需要289天，达到10万

3.22 while 里面的 break 用法

break 表示跳出循环，不管是否满足循环条件，只要碰到break循环就会终止

i = 1

while i <= 10:

	 if i == 3: 

	 break 

	 print("好好学习") 

	 i += 1

print(“循环结束了”)

#输出结果为：2次好好学习

练习题：

循环输入整数，按q退出。循环结束后可以将所有整数相乘并输出结果

result = 1

while True:

	n = int(input("请输入整数：")) 

	result *= n 

	s = input("按任意键继续（q退出）：")

	if s == "q": 

	 		print("循环结束！") 

	 		break

print(“乘积为：{}”.format(result))

3.23 while 里面的 continue 用法

continue 表示跳过当前这次循环，来到下一次循环

#实现1到5之间的所有整数之和

i = 1 sum = 0

while i <= 5:

 if i == 3: 

 	i += 1 

 	continue #3不会累加 

 else:

 	sum += i 

 	i += 1

print(“1到5之间的所有整数之和为：{}”.format(sum))

3.3 循环嵌套

在循环的里面嵌套一个循环

#九九乘法表就是一个很好的嵌套循环例子

i = 1

while i <= 9:

j = 1

while j <= i:

    print("{}x{}={}".format(j,i,i*j), end=" \t")

    j +=1

print()

i +=1

#结果：

1x1=1

1x2=2 2x2=4

1x3=3 2x3=6 3x3=9

1x4=4 2x4=8 3x4=12 4x4=16

1x5=5 2x5=10 3x5=15 4x5=20 5x5=25

1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36

1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49

1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64

1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

容器

字符串的之类是str，列表的类型是list，元组的类型是tuple，字典的类型是dict，set集合的类型是set

4.1 字符串

4.11 字符串的概念

字符串可以由单引号，双引号，3个双引号定义。字符串是一个序列化容器。

序列化指的是元素连续排列，有下标，支持索引和切片。

非序列化没有下标，不支持索引和切片

4.12 字符串通过下标访问对应的元素

下标都是从0开始！！！

s = “好好学习”

s1 = s[0] #如果下标不存在，会报索引越界异常

s2 = s[1]

print(s1)

print(s2)

4.13 字符串的遍历

c = len(s)

print(“字符串的长度为：{}”.format©)

str = “好好学习,拒当备胎”

print(“while循环遍历的结果为:”)

i = 0

while i < 9:

	print(str[i],end=" ") 

	i += 1

##for循环遍历

print("\nfor循环遍历的结果为：")

for s in str:

 print(s,end=" ")

输入一个字符串：明天会更好。逆序输出，输出的是好更会天明

str = input(“请输入一句话：”)

i= len(str)-1 #利用while循环算出总长度再倒序输出

while i >= 0:

print(str[i],end=" ")

i -= 1

4.14 字符串的常用API

4.141 字符串的替换

str = “一存光阴一存金，存金难买存光阴”

str2 = str.replace(“存”,“寸”,2) #有3个参数，第一个参数是旧元素，第二个参数是新元素，第三个参数是替换的数量

print(str2)

4.142 字符串的查找

str = “一存光阴一存金，存金难买存光阴”

index = str.find(“光”) #当要查找的元素不存在的时候，不会报错，只是会返回-1

index2 = str.rfind(“光”) #rfind逆序查找

print(“最左边的光的下标为：”,index)

print(“最右边的光的下标为：”,index2)

4.143 字符串的切片

str = “www.7k7k.com”

s1 = str[:3] #字符串切片，包头不包尾,切出www

s2 = str[4:8] #切出7k7k

s3 = str[9:] #切出com

str = “www.7k7k12345678987654321.com”

#切出com

s = str[-3:] #从右往左

print(s)

例如：编写一个文件检测的脚本：规定后缀名为py或者是java的文件可以通过检测。

其他后缀名的文件不能通过检测。满足条件输出检测通过，不满足条件就输出未通过检测

while True:

text = input("请输入文件名：") 

index = text.rfind(".") #查找文件名中最后一个小数点的下标

if index != -1 and index > 0:

	 houzhui = text[index+1:] 

	 print("后缀名是：",houzhui) 

	 if houzhui == "py" or houzhui == "java":

	 	 print("通过检测") 

	 else:

	 	 print("未通过检测") 

 else:

 	 print("没有后缀或者文件名为空，请重新输入!")

扩展判断字符串是否是数字

str = “12o3”

b = str.isnumeric() #如果字符串中所有的字符都为阿拉伯数字，返回True

print(b)

扩展判断字符串是否为字母

str = “Aabc”

b = str.isalpha() #当字符串中只有纯字母的时候返回True

print(b)

运用：

用户名格式校验：要求用户名不能全部是字母，用户名不能全部是数字，用户名不能含有除字母和数字

以外的符号，也就是说用户名必须是字母和数字的组合（要用所学过的方法编码）

用户名符合条件即输出注册成功，否则输出用户名不符合格式要求

while True:

username = input(“请输入用户名：”)

zm = 0 #定义一个统计字母个数的变量

sz = 0 #定义一个统计字母个数的变量

for u in username:

 if u.isalpha() == True: #说明该字符是字母 

	 zm += 1 

 elif u.isnumeric() == True:#说明该字符是数字 

 	sz += 1 

 	

if zm + sz == len(username) and username.isalpha() == False and username.isnumeric() == False:

 	 print("用户名符合格式要求") 

else:

  	 print("不符合")

4.2 列表

4.21 列表和数组的区别

python中的列表跟java里面的数组非常类似，但是也有区别：

1，python中的列表长度可以变的

2，python的中的列表可以存放不同数据类型的数据

list = [3,“你好”,9,“张三”] #可以存放不同的数据类型

print(list)

4.22 列表添加元素

list = [3,“你好”,9,“张三”]

list.append(6) #列表的长度可以变，可以直接向列表中添加元素

print(list)

4.23 列表删除元素

list = [3,“你好”,9,“张三”]

list.remove(“你好”) #remove表示根据元素去删除

print(list)

list = [3,“你好”,9,“张三”]

list.pop(3) #pop表示根据下标去删除

print(list)

4.24 列表查找元素的下标

list = [3,6,1,9]

xiabiao = list.index(6)

print(“6的下标是：{}”,xiabiao)

4.25 列表修改元素

list = [3,6,1,9]

xiabiao = list.index(6)

print(“6的下标是：{}”,xiabiao)

#将列表中的6替换为66

list[xiabiao] = 66 #根据下标去修改元素

print(“修改后的列表为：”,list)

4.26 列表的排序

list = [3,6,1,9,5,7]

list.sort() #列表中排序的方法,默认是从小到大

print(“排序后：”,list)

#结果是

1，3，5，6，7，9

list = [3,6,1,9,5,7]

list.sort(reverse=True) #列表中排序的方法，从大到小

print(“排序后：”,list)

#结果是

9，7，6，5，3，1

元组

列表支持增删改查所有操作，元组只支持查询操作，不支持修改，删除，添加

元组的好处：1，防止误操作而引起的数据变动。2，节省内存空间。

元组是一个序列化容器，支持索引和切片

5.11 元组的定义

names = (“张三”,“李四”,“王五”)

如果元组只有一个元素，那么末尾一定要加逗号。如果没有加逗号，那么数据类型就是str。

names = (“张三”,)

print(type(names))

如果内元组只有一个元素，那么也要加上逗号

nums = ((5,),)

print(type(nums))

for 嵌套循环遍历元组

for num in nums:

for n in num: 

	print(n,end=" ")

5.12 元组的应用

1，连接mysql数据库，查询数据的结果是元组类型

2，可变参数是通过元组存储参数的

3，多个返回值返回的结果是元组类型

5.13 元组不支持增，删，改

元组是没有增加，删除，更改的API ！！！

5.14 元组的遍历

names = (“张三”,“李四”,“王五”)

for name in names:

 print(name,end=" ")

nums = ((3,5),(9,4),(6,1,2),7) #嵌套元组的遍历

for num in nums:

if type(num) == tuple: 

	for n in num: 

		print(n,end=" ")

else:

	print(num,end=" ")`

5.15 元组的查询

names = (“张三”,“李四”,“王五”)

n = names[1] #根据下标去查询指定的元素

print(n)

xiabiao = names.index(“王五”) #根据元素去查找对应的下标

print(xiabiao)

字典

6.1 字典的概念

字典是一个非序列化容器，不支持索引和切片。元素与元素通过逗号相隔，

把一个元素拆分成键和值。不是通过下标去查询元素，而是通过键去查询值

6.2 字典的定义

student = {“姓名”:“张三”,“性别”:“女”,“年龄”:19} #直接定义了一个带有3个元素的字典

student2 = {} #定义一个空字典

6.3 字典添加元素

stu = {}

stu[“name”] = “张三” #向字典中添加了一个键值为 name 的张三元素

print(stu)

6.4 字典的元素修改

student = {“姓名”:“张三”,“性别”:“女”,“年龄”:19}

student[“年龄”] = 20

print(student)

student.update(年龄=30) #通过关键字修改

当一个键不存在的时候，就是添加。存在的时候值会覆盖上一次的值

6.5 字典的查询

#查询学生的姓名

name=student.get(“姓名2”)

#根据键去查询值,当键不存在的时候，返回None

print(name)

#查询学生的姓名

name = student[“姓名2”] #根据键去查询值,当键不存在的时候，会报错

print(name)

6.6 字典的遍历

6.61 取所有的键和值

phone = {“Logo”:“华为”,“type”:“P30”,“price”:3999,“neicun”:“8G”}

for k,v in phone.items(): #字典的遍历方法

print("{}:{}".format(k,v))

6.62 取所有的键

例如：

k = phone.keys()

for kk in k:

print(kk)

6.63 取所有的值

例如：

v = phone.values()

for vv in v: 

	print(vv)

6.64 嵌套字典

dict = {“键1”:{“键1”:“值”，”键2"：“值2”}，“键2"：{“键1”:“值1”,“键2”:“值2”}}

嵌套字典的遍历

dict = {“键1”:{“键1”:“值1”,“键2”:“值2”},“键2”:{“键1”:“值1”,“键2”:“值2”}}

for k,v in dict.items():

print(k) 

for kk,vv in v.items(): 

	print(kk,vv)

函数

7.1 函数的概念

可以完成某个功能的一段代码，函数不调用不执行

7.2 函数的作用

1，提高代码的复用性

2，减少了项目的维护成本

3，多人开发，提高了开发效率

7.4 函数的定义

#函数名符合变量的命名规范

#1，字母和数字和下划线,$的组合

#2,变量的开头不能是数字

#3，变量不能是关键字

例如：打印三角形的函数

def print_star(): #def关键字定义函数

 """ 

 打印三角形的函数 

入参：xx 

:return:null 

"""

 i = 1 

 while i <= 5: 

 	print("#" * i, end=" ") 

 	print() 

 	i += 1

#调用函数

print_star()

7.5 函数的调用

在当前文件中调用直接用函数名调用

在其他文件中需要导包后调用

from py_day02.人机猜拳 import *

print_star

7.6 函数的参数

7.61 单个参数

#编写一个榨汁机的函数，这个函数可以榨果汁

def zzj():#函数没有参数意味着只能榨一种果汁

print("榨好了一杯西瓜汁")

zzj()

def zzj2(shuiguo): #有参数后意味想喝什么果汁都可以

print("榨好了一杯{}汁".format(shuiguo))

while True:

 sg = input("请问你想喝啥？") 

 zzj2(sg)

7.62 多个参数

例如：

#完成2个任意之和

def add2(num1,num2):

 sum = num1 + num2 

 print("结果是：{}".format(sum))

add2(3,4)

7.63 参数的总结

形参：在编写函数时定义的参数称之为是形参

实参：在调用函数的时候传入进去的参数称之为实参

形参和实参的关系：

1，形参和实参的个数必须要一样

2，形参和实参的数据类型必须要一样

3，形参和实参的位置顺序必须要一样

例如：

定义一个函数，要求：计算x到y之间所有的偶数之和。

def sumOu(x,y):

sum = 0 

i = x 

while i <= y: 

	if i % 2 == 0: 

		sum += i 

	i += 1 

print("偶数之和为：",sum)

sumOu(2,7) #调用函数并传入参数

7.7 函数的返回值 return

概念

后端工程师 -->编写接口，接口返回数据（JSON/xml）

前端工程师 -->得到json数据解析，展示在网页上一些常见的有返回值的函数：

比如 str = input(“请输入：”)#这里的str就是函数的返回值

没有返回值的函数，有print语句的：只能打印在控制台，无法在其他地方使用函数加工后的成品

有返回值的函数：调用函数的时候，可以得到该函数加工后的成品，至于我是打印还是传递到其他地方

7.71 单个返回值

例如：

实现2个数的相加函数

def add(n1, n2):

sum = n1 + n2 

return sum                     #返回sum的结果

result = add(3,7)

print(result)

7.72 多个返回值

多个返回值需要用逗号隔开，调用多个返回值的函数会得到一个元组，

该元组中存储的就是函数的那多个返回值，遍历即可使用里面的返回值了

def computer(n1,n2):

 sum = n1 + n2 

 jian = n1 - n2 

 return sum,jian     #返回sum跟jian的结果

j1 = computer(7,3)

print(type(j1)) #多个返回值是一个元组来存储

print(j1)

for j in j1: #利用for遍历出来

print(j)

扩展函数与返回值的应用场景

生成指定长度的验证码（由数字和大小写英文字母构成的随机字符串）

就是说如果用户输入4，那么就生成一个4位数的随机验证码。

用户输入5，就生成一个5位数的随机验证码…

要求：编写函数完成。(返回验证码)

import time

def makeGode(length):

str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" 

import random 

i = 1 

code = "" 

while i <= length: 

	r = random.randint(0,len(str)-1)     #利用随机数生成下标并获取对应的下标的字符串内容

	code += str[r]                                  #获取对应下标的字符串内容

	i += 1 

return code

while True:

yanzhengma = makeGode(5) 

print("得到的这个验证码是：{}".format(yanzhengma)) time.sleep(0.3)

7.8 函数中的默认参数

定义函数的时候，给参数一个默认值，那么调用函数不传入参数默认就是默认值

传了参数以我传入的参数为准。

def add(n1=100,n2=200): #赋予形参默认参数数值如果调用时不传入参数则会使用默认参数数值

sum = n1 + n2 

return sum

num = add(5,7)

print(num)

7.9 函数的关键字参数

如果没有指定关键字参数，那么默认就是位置参数。位置参数要求参数的顺序一一对应

需要注意的一点：关键字参数只能在位置参数的后面

def add(n1,n2):

sum = n1 - n2 

return sum

num = add(n2=5,n1=7) #关键字参数。

print(num)

7.10 函数的可变参数

调用函数的时候参数的个数可以变化，那么就要求在定义函数的时候，形参的个数不能写死。

要用*args来定义。args可以用其他名字命名。按规范最好使用args命名。args的数据类型是元组

案例：

实现所有参数的求和

def func(*args): #可变参数可以传入多个参数按照情况需要传入几个就可以传入几个

print(type(args)) 

sum = 0 

for a in args: 

	sum += a 

	return sum

jieguo = func(6,7,3,4)

print(jieguo)

7.11 成员变量和局部变量

7.12 成员变量（全局变量）

定义在函数或者方法的外面的变量称之为成员变量，可以在当前脚本中所有的函数或者方法中被使用

例如：

money = 500 #成员变量

#可以从函数里面去修改成员变量的值，需要去引入一个关键字global去申明成员变量

def getMoney():

print("获得了{}元".format(money))

def setMoney():

m = money - 200 

return m

getMoney()

qian = setMoney()

print(“钱变成了{}元”.format(qian))

7.13 局部变量

定义在函数或者方法的里面的变量称之为局部变量，只能在当前函数或者方法中被使用.参数也是当前函数的局部变量

def getMoney():

money = 500

print("获得了{}元".format(money))

def setMoney():

m = money - 200 #money报错，无法使用  因为money是函数getMoney中定义的局部变量此函数无法调用

return m

getMoney()

qian = setMoney()

print(“钱变成了{}元”.format(qian))

7.14 申明成员变量（全局变量）

想在函数的里面去使用这个成员变量，并且修改这个成员变量。

需要去引入一个关键字 global 去申明成员变量

例如：

money = 500 # 成员变量

def getMoney():

global money       #只有申明了  函数内部对money进行的操作才会同步更新到全局变量

money -= 100         #money会减少

print("函数里面的money:",money)

getMoney()

print(“成员变量的money”,money)

Groot。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python 快速入门学习

Python 快速入门学习python的基本语法1.1 变量1.12 如何定义变量1.13 输出一个变量1.14 变量的数据类型1.15 变量的运算1.16 变量的输入1.17 变量的类型转换1.18 变量的格式化输出逻辑判断（分支结构）2.1 单个分支结构2.2 多个分支结构2.3 逻辑运算符2.31 and 用法2.32 or 用法2.33 not 用法2.4 逻辑嵌套循环3.1 循环的定义3.2 while 循环的语法3.21 while 循环实现
复制链接

扫一扫