由于一年多没有接触python,现在恶补了下python基础语法,为以后的深度学习打下基础。现总结如下,希望对大家有所帮助。
Python基础学习路线流程图
PyCharm是一种Python的集成开发环境,带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具
Anaconda(官方网站)就是可以便捷获取包且对包能够进行管理,同时对环境可以统一管理的发行版本。Anaconda包含了conda、Python在内的超过180个科学包及其依赖项。
注释分为两类:单行注释 和 多行注释。
只能注释一行内容,语法如下:
# 注释内容
可以注释多行内容,一般用在注释一段代码的情况, 语法如下:
"""
第一行注释
第二行注释
第三行注释
"""
'''
注释1
注释2
注释3
'''
快捷键: ctrl + /
定义变量
变量名 = 值
变量名自定义,要满足标识符命名规则。
标识符命名规则是Python中定义各种名字的时候的统一规范,具体如下:
False None True and as assert break class
continue def del elif else except finally for
from global if import in is lambda nonlocal not or pass raise return try while with yield
my_name = '北山啦'
print(my_name)
北山啦
输入
在Python中,程序接收用户输入的数据的功能即是输入。
语法:
input("提示信息")
input
,等待用户输入,输入完成之后才继续向下执行。input
接收用户输入后,一般存储到变量,方便使用。input
会把接收到的任意用户输入的数据都当做字符串处理。address = input('请输入您的CSDN博客地址:')
请输入您的CSDN博客地址:https://beishan.blog.csdn.net/
print(f'您输入的密码是{address}')
# <class 'str'>
print(type(address))
您输入的密码是https://beishan.blog.csdn.net/
<class 'str'>
输出
print('hello Python')
age = 18
print(age)
# 需求:输出“今年我的年龄是18岁”
age = 20
name = '北山啦'
student_id = '01830115'
print('我的名字是%s' % name, end='\n')
print('我的学号是%s' % student_id)
print(f'我的名字是{name},今年{age+1}岁了')
我的名字是北山啦
我的学号是01830115
我的名字是北山啦,今年21岁了
weight = 74.22
print(f"{weight}")
print("{:.3f}".format(weight))
74.22
74.220
stu_id = 1
print("{:03d}".format(stu_id))
001
所谓的格式化输出即按照一定的格式输出内容。
格式化符号
格式符号 | 转换 |
---|---|
%s | 字符串 |
%d | 有符号的十进制整数 |
%f | 浮点数 |
%c | 字符 |
%u | 无符号十进制整数 |
%o | 八进制整数 |
%x | 十六进制整数(小写ox) |
%X | 十六进制整数(大写OX) |
%e | 科学计数法(小写’e’) |
%E | 科学计数法(大写’E’) |
%g | %f和%e的简写 |
%G | %f和%E的简写 |
我们可以使用type()函数,来查看数据类型
num1 = 1
num2 = 1.1
print(type(num1))
print(type(num2))
print(type('北山啦'))
print(type(True))
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
转换数据类型
转换数据类型的函数
函数 | 说明 |
---|---|
int(x [,base ]) | 将x转换为一个整数 |
float(x ) | 将x转换为一个浮点数 |
complex(real [,imag ]) | 创建一个复数,real为实部,imag为虚部 |
str(x ) | 将对象 x 转换为字符串 |
repr(x ) | 将对象 x 转换为表达式字符串 |
eval(str ) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
tuple(s ) | 将序列 s 转换为一个元组 |
list(s ) | 将序列 s 转换为一个列表 |
chr(x ) | 将一个整数转换为一个Unicode字符 |
ord(x ) | 将一个字符转换为它的ASCII整数值 |
hex(x ) | 将一个整数转换为一个十六进制字符串 |
oct(x ) | 将一个整数转换为一个八进制字符串 |
bin(x ) | 将一个整数转换为一个二进制字符串 |
一些例子
需求:input接收用户输入,用户输入“1”,将这个数据1转换成整型。
num = input('请输入您的幸运数字:')
print(f"您的幸运数字是{num}")
print(type(num))
print(type(int(num)))
# 1. float() -- 转换成浮点型
num1 = 1
print(float(num1))
print(type(float(num1)))
# 2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))
# 3. tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))
# 4. list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))
# 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))
请输入您的幸运数字:20
您的幸运数字是20
<class 'str'>
<class 'int'>
1.0
<class 'float'>
<class 'str'>
(10, 20, 30)
<class 'tuple'>
[100, 200, 300]
<class 'list'>
<class 'int'>
<class 'list'>
<class 'tuple'>
算数运算符
()
高于 **
高于 *
/
//
%
高于 +
-
python中的条件判断共三种:
if 条件:
条件成立执行的代码
if 条件:
条件成立执行的代码
else:
条件不成立执行的代码
if 条件1:
条件1成立执行的代码
elif 条件2:
条件2成立执行的代码
else:
以上条件都不成立执行的代码
age = int(input('请输入他的年龄:\n'))
if age < 18:
print(f"你输入的年龄是{age},童工")
elif 18 <= age <= 60:
print("你输入的年龄是{},合法".format(age))
elif age > 60:
print("你输入的年龄是%d,退休" % age)
请输入他的年龄:
20
你输入的年龄是20,合法
让我们直接用一个猜拳小游戏
,来熟悉if条件语句吧
"""
提示:0-石头,1-剪刀,2-布
1. 出拳
玩家输入出拳
电脑随机出拳,使用random库随机生成0,1,2
"""
import random
computer = random.randint(0, 2)
# print(computer)
player = int(input('请出拳:0-石头,1-剪刀,2-布:'))
if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
print('玩家获胜')
elif player == computer:
print('平局')
else:
print('电脑获胜')
请出拳:0-石头,1-剪刀,2-布:2
电脑获胜
本章节将向大家介绍Python的循环语句,程序在一般情况下是按顺序执行的。
编程语言提供了各种控制结构,允许更复杂的执行路径。
循环语句允许我们执行一个语句或语句组多次,下面是在大多数编程语言中的循环语句的一般形式:
while循环
while 条件:
条件成立执行代码
具体例子:
# 输出5遍博客名
t = 0
while(t < 5):
print("北山啦")
t += 1
北山啦
北山啦
北山啦
北山啦
北山啦
# 1-100累加
i = 1
sum = 0
while i <= 100:
sum += i
i += 1
print(sum)
5050
1-100的偶数累加和
i = 1
sum = 0
while i <= 100:
if i % 2 == 0:
sum += i
i += 1
print(sum)
2550
i = 0
sum = 0
while i <= 100:
sum += i
i += 2
print(sum)
2550
break和continue
break和continue是循环中满足一定条件退出循环的两种不同方式。
具体例子如下
# 循环吃5个苹果,吃完了第3个吃饱了,第4和第5个不吃了
i = 1
while i <= 5:
if i == 4:
break
print(f"吃了第{i}个苹果")
i += 1
吃了第1个苹果
吃了第2个苹果
吃了第3个苹果
i = 1
while i <= 5:
if i == 3:
print("吃出了一个大虫子,这个苹果不吃了")
# 如果使用continue,在continue之前一定要修改计数器,否则进入死循环
i += 1
continue
print(f"吃了第{i}个苹果")
i += 1
吃了第1个苹果
吃了第2个苹果
吃出了一个大虫子,这个苹果不吃了
吃了第4个苹果
吃了第5个苹果
while嵌套的简单应用
j = 0
while j < 3:
i = 0
while i < 3:
print("CSDN")
i += 1
j += 1
print("北山啦")
CSDN
CSDN
CSDN
北山啦
CSDN
CSDN
CSDN
北山啦
CSDN
CSDN
CSDN
北山啦
一行输出5个星号,重复打印5行
j = 0
while j < 5:
i = 0
while i < 5:
print("*", end='')
i += 1
print()
j += 1
*****
*****
*****
*****
*****
打印三角形
j = 0
while j < 5:
i = 0
while i <= j:
print("*", end='')
i += 1
print()
j += 1
*
**
***
****
*****
九九乘法表
# 九九乘法表
for i in range(1, 10):
for j in range(1, i+1):
print(f'{j}*{i}={i*j}\t', end='')
print()
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
# 九九乘法表
i = 1
while i <= 9:
j = 1
while(j <= i):
print('{}*{}= {}'.format(j, i, i*j), end='\t')
j += 1
print('')
i += 1
1*1= 1
1*2= 2 2*2= 4
1*3= 3 2*3= 6 3*3= 9
1*4= 4 2*4= 8 3*4= 12 4*4= 16
1*5= 5 2*5= 10 3*5= 15 4*5= 20 5*5= 25
1*6= 6 2*6= 12 3*6= 18 4*6= 24 5*6= 30 6*6= 36
1*7= 7 2*7= 14 3*7= 21 4*7= 28 5*7= 35 6*7= 42 7*7= 49
1*8= 8 2*8= 16 3*8= 24 4*8= 32 5*8= 40 6*8= 48 7*8= 56 8*8= 64
1*9= 9 2*9= 18 3*9= 27 4*9= 36 5*9= 45 6*9= 54 7*9= 63 8*9= 72 9*9= 81
使用列表推导式
print('\n'.join(
['\t'.join([f"{j}*{i}={i*j}" for j in range(1, i + 1)]) for i in range(1, 10)]))
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
for循环 语法:
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2
......
str1 = 'CSDN北山啦'
for i in str1:
print(i)
C
S
D
N
北
山
啦
for…else 之break和continue
# break
str2 = 'https://beishan.blog.csdn.net/'
for i in str2:
if i == ':':
break
print(i)
else:
print("循环正常结束执行的else代码")
h
t
t
p
s
# continue
str2 = 'https://beishan.blog.csdn.net/'
for i in str2:
if i == ':':
continue
print(i)
else:
print("循环正常结束执行的else代码")
h
t
t
p
s
/
/
b
e
i
s
h
a
n
.
b
l
o
g
.
c
s
d
n
.
n
e
t
/
循环正常结束执行的else代码
我们可以使用type()
函数来查看数据类型
字符串是Python中最常见的数据类型,我们一般使用引号来创建字符串。
可以使用单引号,也可以使用三引号
a = 'https://beishan.blog.csdn.net/'
print(type(a))
b = """原创:CSDN北山啦"""
print(type(b))
c = "I'm 北山啦"
print(c)
print(type(c))
<class 'str'>
<class 'str'>
I'm 北山啦
<class 'str'>
在Python中,使用input()
接收用户输入。在Python中,使用print()
接收用户输入。
切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
语法
序列[开始位置下标:结束位置下标:步长]
注意
1. 不包含结束位置下标对应的数据, 正负整数均可;
2. 步长是选取间隔,正负整数均可,默认步长为1。
name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第一个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba
cde
cde
abcde
bcdefg
abcdefg
aceg
abcdef
def
gfedcba
字符串常用操作
字符串的常用操作方法有查找、修改和判断三大类。
查找
:find()、index()、count()
find():检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则返回-1。
index():检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则报异常。
count():返回某个子串在字符串中出现的次数
修改
:replace()、split()、join()
字符串序列.split(分割字符, num)
注意:num表示的是分割字符出现的次数,即将来返回数据个数为num+1个。
字符或子串.join(多字符串组成的序列)
capitalize():将字符串第一个字符转换成大写。
title():将字符串每个单词首字母转换成大写。
lower():将字符串中大写转小写。
upper():将字符串中小写转大写。
strip():删除字符串两侧空白字符。lstrip()、rstrip()
center():返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串,语法和ljust()相同。
判断
:startswith()、endwith()、isalpha()、isdigit()
这样的函数有很多,需要用的时候自己百度即可,熟悉最常见的例如:join()、split()即可。
列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
name_list = ['欢迎', '关注', '北山啦']
print(name_list[0])
print(name_list[1])
print(name_list[2])
欢迎
关注
北山啦
常见的函数
index()、count()、len()
name_list = ['欢迎', '关注', '北山啦']
print(name_list.index('北山啦'))
print(name_list.count('北山啦'))c
print(len(name_list))
2
1
3
判断是否存在
in:判断指定数据在某个列表序列,如果在返回True,否则返回False
not in:判断指定数据不在某个列表序列,如果不在返回True,否则返回False
name_list = ['欢迎', '关注', '北山啦']
print('欢迎' in name_list)
print('Lilys' in name_list)
True
False
print('北山' not in name_list)
print('Lilys' not in name_list)
True
True
常用操作方法
同时列表也有reverse()、sort()这样的函数
import random
teachers = ['zhangzk', 'dfbdaf', 'dfad', 'dfa', 'etw', 'dfa', 'dgdag']
offices = [[], [], []]
for name in teachers:
num = random.randint(0, 2)
offices[num].append(name)
print(offices)
[['dfbdaf', 'dfa'], ['zhangzk', 'dfa', 'dgdag'], ['dfad', 'etw']]
[i for j in offices for i in j]
['dfbdaf', 'dfa', 'zhangzk', 'dfa', 'dgdag', 'dfad', 'etw']
for name in offices:
for i in name:
print(i, end=' ')
etw dgdag dfad dfa zhangzk dfbdaf dfa
一个元组可以存储多个数据,元组内的数据是不能修改的
元组特点:定义元组使用小括号,且逗号隔开各个数据,数据可以是不同的数据类型。
t1 = (10, 20, 30)
t2 = (10,)
print(type(t1))
print(type(t2))
<class 'tuple'>
<class 'tuple'>
如果定义的元组只有一个数据,那么这个数据后面也好添加逗号,否则数据类型为唯一的这个数据的数据类型
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
<class 'tuple'>
<class 'int'>
<class 'str'>
常用方法和list类似:index()、len()、count()
字典特点:
创建字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} # 有数据的字典
dict2 = {} # 创建空字典
dict3 = dict() # 创建空字典
print(type(dict1))
<class 'dict'>
字典的常见操作
如果key存在则修改这个key对应的值;如果key不存在则新增此键值对
dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
print(dict1)
{'name': 'Rose', 'age': 20, 'gender': '男'}
dict1['id'] = 110
print(dict1)
{'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
del、clear
dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
# del(dict1)
del dict1['gender']
print(dict1)
{'name': '北山啦', 'age': 20}
dict1.clear()
print(dict1) # 清空字典
{}
写法:字典序列[key] = 值
注意:如果key存在则修改这个key对应的值 ;如果key不存在则新增此键值对。
dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
dict1['age'] = 22
print(dict1)
{'name': '北山啦', 'age': 22, 'gender': '男'}
如果查找的key存在,则返回对应的值,否则报错
dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
print(dict1['name'])
print(dict1['id'])
北山啦
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_1196/2064109912.py in <module>
1 dict1 = {'name':'北山啦','age':20,'gender':'男'}
2 print(dict1['name'])
----> 3 print(dict1['id'])
KeyError: 'id'
字典当中常用的函数
get()
字典序列.get(key, 默认值)
注意:如果当前查找的key不存在则返回第二个参数(默认值),如果省略第二个参数,则返回None。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None
keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])
items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
字典当中的循环遍历
dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
name
age
gender
for value in dict1.values():
print(value)
北山啦
20
男
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
('name', 'Tom')
('age', 20)
('gender', '男')
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
print(f'{key}:{value}')
name:Tom
age:20
gender:男
创建集合使用{}
或set()
, 但是如果要创建空集合只能使用set()
,因为{}
用来创建空字典。
集合的特点:
s1 = {10, 20, 30, 40, 50}
print(s1)
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)
s3 = set('abcdefg')
print(s3)
s4 = set()
print(type(s4)) # set
s5 = {}
print(type(s5)) # dict
{50, 20, 40, 10, 30}
{50, 20, 40, 10, 30}
{'a', 'd', 'b', 'e', 'f', 'g', 'c'}
<class 'set'>
<class 'dict'>
常见操作
s1 = {10, 20, 30, 40, 50}
s1.add(100) # 集合是可变的类型
print(s1)
{50, 20, 100, 40, 10, 30}
s1.update([30, 40, 50, 60, 70])
s1 # 集合可以去掉重复数据
{10, 20, 30, 40, 50, 60, 70}
s1.remove(10)
s1
{20, 30, 40, 50, 60, 70}
s1.discard(10) # 没有该数据不会报错,remove会报错
s1
{20, 30, 40, 50, 60, 70}
运算符描述支持的容器类型+合并字符串、列表、元组*复制字符串、列表、元组in元素是否存在字符串、列表、元组、字典not in元素是否不存在字符串、列表、元组、字典
函数 | 描述 |
---|---|
len() | 计算容器中元素个数 |
del 或 del() | 删除 |
max() | 返回容器中元素最大值 |
min() | 返回容器中元素最小值 |
range(start, end, step) | 生成从start到end的数字,步长为 step,供for循环使用 |
enumerate() | 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。 |
利用相应的函数即可实现数据类型转化
enumerate(可遍历对象, start=0)
注意:start参数用来设置遍历数据的下标的起始值,默认为0。
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1, 1):
print(i)
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}')
下标是1, 对应的字符是a
下标是2, 对应的字符是b
下标是3, 对应的字符是c
下标是4, 对应的字符是d
下标是5, 对应的字符是e
列表推导式
# while实现
list1 = []
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# for循环实现
list1 = []
for i in range(10):
list1.append(i)
print(list1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list1 = [i for i in range(10)]
print(list1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
带if的列表推导式
# 创建0-10的偶数列表
list1 = [i for i in range(0, 11, 2)]
print(list1)
[0, 2, 4, 6, 8, 10]
list1 = [i for i in range(0, 11) if i % 2 == 0]
print(list1)
[0, 2, 4, 6, 8, 10]
多个for循环实现列表推导式
list1 = []
for i in range(1, 3):
for j in range(3):
list1.append((i, j))
print(list1)
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
列表推导式解包
a = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
b = [x for b in a for x in b]
print(b)
[1, 2, 3, 1, 2, 3, 1, 2, 3]
字典推导式
快速合并列表为字典或者体取字典中目标数据
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)
{1: 1, 2: 4, 3: 9, 4: 16}
合并列表为字典
list1 = ['name', 'age', 'gender']
list2 = ['beishan', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
{'name': 'beishan', 'age': 20, 'gender': 'man'}
提取字典中目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)
{'MBP': 268, 'DELL': 201}
集合推导式
list1 = [1, 1, 2]
set1 = {i**2 for i in list1}
print(set1)
{1, 4}
函数就是将一段具有独立功能的代码块整合到一个整体并命名,在需要的位置调用这个名称即可完成对应的需求。
函数在开发过程中,可以更高效的实现代码重用。
函数的作用:封装代码,高效的代码重用
函数使用步骤
def 函数名():
代码1
代码2
...
函数名()
函数的参数:函数调用的时候可以传入真实数据,增大函数的使用的灵活性
函数的返回值
return 表达式
函数的说明文档
def 函数名():
""" 函数说明文档 """
函数嵌套调用:一个函数内部嵌套调用另外一个函数
定义函数
def 函数名(参数):
代码1
代码2
......
调用函数
函数名(参数)
注意:
1. 不同的需求,参数可有可无。
2. 在Python中,函数必须==先定义后使用==。
使用函数,完成加法
def sum_num(a, b):
return a + b
# 用result变量保存函数返回值
result = sum_num(1, 2)
print(result)
3
对于python当中许多内置的函数,可以使用help()
来获得函数的具体使用方法
当然大家在平时写函数的过程中,为了便于其他人员的使用,增加可读性,也可以适当写函数说明文档
def 函数名(参数):
""" 说明文档的位置 """
代码
......
help(函数名)
help(print)
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
使用help(函数名)就可以很容易看到print()当中的参数了
def sum_num(a, b):
""" 求和函数 """
return a + b
help(sum_num)
Help on function sum_num in module __main__:
sum_num(a, b)
求和函数
同时在python中函数也可以嵌套使用的
def testB():
print('---- testB start----')
print('这里是testB函数执行的代码...(省略)...')
print('---- testB end----')
def testA():
print('---- testA start----')
testB()
print('---- testA end----')
testA()
---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----
如果函数A中,调用了另外一个函数B,那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置。
变量作用域指的是变量生效的范围,主要分为两类:局部变量和全局变量。
所谓局部变量是定义在函数体内部的变量,即只在函数体内部生效。
def testA():
a = 100
print(a)
testA() # 100
print(a) # 报错:name 'a' is not defined
变量a是定义在
testA
函数内部的变量,在函数外部访问则立即报错。
局部变量的作用:在函数体内部,临时保存数据,即当函数调用完成后,则销毁局部变量。
所谓全局变量,指的是在函数体内、外都能生效的变量。
思考:如果有一个数据,在函数A和函数B中都要使用,该怎么办?
答:将这个数据存储在一个全局变量里面。
a = 100 # 定义全局变量a
def testA():
print(a) # 访问全局变量a,并打印变量a存储的数据
def testB():
print(a) # 访问全局变量a,并打印变量a存储的数据
testA() # 100
testB() # 100
global
关键字声明a是全局变量
UnboundLocalError: local variable 'count' referenced before assignment
a = 100 # 定义全局变量a
def testA():
print(a)
def testB():
global a
a = 200
print(a)
testA()
testB()
100
200
返回值
思考:如果一个函数如些两个return (如下所示),程序如何执行?
def return_num():
return 1
return 2
result = return_num()
print(result) # 1
答:只执行了第一个return,原因是因为return可以退出当前函数,导致return下方的代码不执行。
思考:如果一个函数要有多个返回值,该如何书写代码?
def return_num():
return 1, 2
result = return_num()
print(result) # (1, 2)
注意:
return a, b
写法,返回多个数据的时候,默认是元组类型。def return_num():
return (10, 20)
return_num()
(10, 20)
位置参数:调用函数时根据函数定义的参数位置来传递参数。
注意:传递和定义参数的顺序及个数必须一致。
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('北山啦', 20, '男')
您的名字是北山啦, 年龄是20, 性别是男
函数调用,通过“键=值”形式加以指定。可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)
您的名字是Rose, 年龄是20, 性别是女
您的名字是小明, 年龄是16, 性别是男
注意:函数调用时,如果有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序。
user_info(gender='男', age=16, '小明')
File "C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_13808/292338224.py", line 1
user_info(gender='男', age=16,'小明')
^
SyntaxError: positional argument follows keyword argument
缺省参数也叫默认参数,用于定义函数,为参数提供默认值,调用函数时可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调用)。
注意:函数调用时,如果为缺省参数传值则修改默认参数值;否则使用这个默认值。
def user_info(name, age, gender='男'):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('TOM', 20)
user_info('Rose', 18, '女')
您的名字是TOM, 年龄是20, 性别是男
您的名字是Rose, 年龄是18, 性别是女
不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时,可用包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会显得非常方便。
def user_info(*args):#*必须写,args可以为其他的
print(args)
# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)
注意:传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为一个
元组
(tuple),args是元组类型,这就是包裹位置传递。
def user_info(**kwargs):
print(kwargs)
# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)
综上:无论是包裹位置传递还是包裹关键字传递,都是一个组包的过程。
def return_num():
return 100, 200
num1, num2 = return_num()
print(num1)
print(num2)
100
200
dict1 = {'name': 'beishanla', 'age': 20}
a, b = dict1
print(a)
print(b)
name
age
for i in dict1.keys():
print(i)
name
age
lambda 参数列表 : 表达式
def sum_number(num):
if num == 1:
return 1
return num + sum_number(num-1)
sum_number(3)
lambda表达式的简单例子
f1 = lambda x,y:x+y
print(f1(1, 2))
3
f2 = lambda a,b:a if a > b else b
f2(1000,5000)
5000
列表数据按字典key的值排序
infos = [
{'name': 'beishanla', 'age': 20},
{'name': 'zhagnzk', 'age': 21},
{'name': 'zhangy', 'age': 22},
]
infos.sort(key=lambda x: x['name'], reverse=True)
print(infos)
[{'name': 'zhangy', 'age': 22}, {'name': 'zhagnzk', 'age': 21}, {'name': 'beishanla', 'age': 20}]
map
:
map(func, lst),将传入的函数变量func作用到lst变量的每个元素中,并将结果组成新的列表(Python2)/迭代器(Python3)返回。
square = list(map(lambda x: x**2, range(10)))
print(square)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
square = [x**2 for x in range(10)]
print(square)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
filter
:filter(func, lst)函数用于过滤序列, 过滤掉不符合条件的元素, 返回一个 filter 对象。如果要转换为列表, 可以使用 list() 来转换。
result = list(filter(lambda x: x % 2 == 0, range(10)))
result
[0, 2, 4, 6, 8]
reduce
:reduce(func,lst),其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。
注意:reduce()传入的参数func必须接收2个参数。
import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
return a + b
result = functools.reduce(func, list1)
print(result) # 15
15
文件操作步骤
文件对象 = open(目标文件, 访问模式)
with open(目标文件,访问模式):
操作
文件对象.read()
文件对象.readlines()
文件对象.readline()
文件对象.write()
关闭
文件对象.close()
主访问模式
文件和文件夹操作
到这里就结束了,如果对你有帮助,欢迎点赞关注,你的点赞对我很重要。作者:北山啦