Python
文章目录
Python是一种面向对象的高级编程语言
注释
# 注释 ctrl + / 注释生成或取消
'''
中间为注释
'''
数据类型
字符串类型 使用单引号或者双引号
整型(int)、浮点型(float)、复数(complex)、字符串(str)
列表类型 (list)
names = ['风清扬','林青霞','梅超风']
字典类型(dict)
person = {'name':'小明','age':18,'addr':'四川','身高':'180cm'}
元组类型(tuple)
nums = (1,8,9,2,3,0)
集合类型(set)
x = {9,'hello','hi','good',True}
布尔类型(bool)
首字母大写:False True
查看数据类型
#使用type内置类可以查看一个变量对应的数据类型
print(type(a))
在python里,变量是没有数据类型的,我们所说的变量的数据类型,其实是变量对应值的数据类型
标识符和关键字
标识符 :变量、模块名,函数名,类名…….
标识符的命名规则与规范:
-
规则:
- 由数字、字母、下划线组成,不能以数字开头
- 严格局分字母大小写
- 不能使用关键字(在Python语言里,有特色含义的单词)
-
规范:
-
遵守一定的命名规范
-
小驼峰命名法:第一个单词的首字母小写,以后每个单词的首字母都大写
-
大驼峰命名法:每个单词的首字母都大写
-
使用下划线连接:如:user_name_and_password
#在python里的变量,函数和模块名使用下划线连接;类名使用大驼峰命名法
-
-
输出
Python里使用 print内置函数 ,来输出内容
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
-
sep 参数用来表示输出时,每个值之间使用哪种字符作为分隔。默认使用空格作为分隔符
-
end 当执行完一个print语句以后,接下来要输出的字符。默认 \n 表示换行
输入
Python里使用 input内置函数 接受用户的输入
不管用户输入什么,变量保存的结果都是字符串
整数的表示方式
二进制、八进制、十六进制、十进制 在Python都能表示
a = 98 #默认数字都是十进制数字
b = 0b101101101 # 以0b开头的数字是二进制
c = 0o34 # 以0o开头的数字是八进制
d = 0x23 # 以0x开头的数字是十六进制
## 当使用print语句打印一个数字时,默认是使用十进制打印输出
使用代码进行进制转换
a = 12
#十进制转换为二进制
print(bin(a))
#十进制转换为八进制
print(oct(a))
#十进制转换为十六进制
print(hex(a))
数据类型的转换
使用 int 内置类可以将其他类型数据转换为整数
age = int(age)
其他数据类型必须是合法数字
x = '1a2c'
y = int(x,16) #把字符串 1a2c 当作十六进制转换成整数
- 其他类型同理
在Python中,只有空字符串‘ ’ ,“ ”,数字0,空列表[ ],空字典{},空元组(),空集合set(),空数据None会被转换成False,其他的都被转换成True
在计算机里,True和False其实是数字 1 和 0 来保存的
print(True + 1) #2
print(False + 1) #1
运算符
- 在Python3中两个整数相除的结果是一个浮点数
注:
print(3 ** 3) #27
# **为幂运算
print(10 // 3) #3 整除,只取整数部分
print(-5 // 2) #-2.5 取整,都是向下取整
-
字符串里只支持加法和乘法运算符
1、加法运算符: 将多个字符串拼接为一个字符串
2、乘法运算符: 可以用于数字和字符串之间,用来将一个字符串重复多次
print('hello' * 2) #hellohello
-
赋值运算符特殊场景
#拆包 m,n = 3,5 x = 'hello','world','person' o,*p,q = 1,2,3,4,5,6 print(o,p,q) # 1 [2, 3, 4, 5] 6 ## 有*的变量名即为可变长度
-
比较运算符
print('abc' > 'b') # Flase 因为(a)97<(b)98 # 字符串之间使用比较运算符,会根据各个字符的编码值逐一比较 # 如上面 a,b,c 都会与b比较
数字和字符串之间,做 == 运算结果为False,做 != 为True
-
逻辑运算符
1、逻辑与:and
2、逻辑或:or
3、逻辑非:not
逻辑运算符的短路:and有一个不行就都不行,or有一个行就都行
逻辑运算的结果,不一定是布尔值 如下:
逻辑与运算做取值时,取第一个为False的值;如果所有的运算数都是True,取最后一个值
print(3 and 5 and 0 and 'hello') # 0 print('good' and 'yes' and 'ok' and 100) # 100
逻辑或运算做取值时,取第一个为True的值;如果所有的运算数都是False,取最后一个值
print(0 or [] or 'list' or 5 or 'ok') # list print(0 or [] or {} or ()) # ()
-
位运算符
-
按位与 & :同为1,否则为0
-
按位或 **| ** :同为1则为1,否则为0
-
按位异或 ^ :相同为0,不同为1
-
按位左移 << :即在右边补0 或者( a << n ==> a * 2的n次方)
x = 5 # 101 print(x << 3) # 101000 # 也可以 5*2的三次方
-
按位右移 >> :即在左边补0 或者( a << n ==> a / 2的n次方)
-
按位取反 ~
按位运算将化成二进制运算,然后化成十进制显示
-
运算符的优先级
-
逻辑运算符
not > and >or
条件判断语句
Python里不支持 switch…case 语句
if
-
if语句格式
age = int(input('请输入你的年龄')) if age < 18: print('未满十八岁,禁止入内')
-
if…else语句格式
age = int(input('请输入你的年龄')) if age < 18: print('未满十八岁,禁止入内') else: print('已满十八岁,可以入内')
-
if…elif…elif语句格式
socre = int(input('请输入成绩')) if 60 > socre >= 0: print("菜") elif 80 > socre >= 60: print('一般般') elif 100 >= socre >= 80: print('还可以') else: print('输入错误')
Pytho语言里,使用强制缩进来表示语句之间的结构
pass 关键词在python里没有意义,只是单纯的用来占位,保证语句的完整性
注意点
-
区间判断:
Python里可以使用连续的区间判断,如: 100 > X > 50
而在有些语言中,需要逻辑运算符连接
三元表达式
num1 = int(input('please input:'))
num2 = int(input('please input again:'))
x = num1 if num1 > num2 else num2
print('较大数',x)
循环语句
Python里不支持 do…while 循环
一、while
Python里没有自增自减运算符(即:++、- -)
while x < 10:
print('hello')
x += 1
-
例子:九九乘法表
#九九乘法表 i = 0 while i < 9: i += 1 j = 0 while j < i: j += 1 print(j,'*',i,'=',j*i,sep='',end='\t') #sep用来收缩,\t用来均匀空格 print()
二、for…in
和C语言的for不一样
for语句格式:for ele in iterable
注意:in 的后面必须放可迭代对象(如: 字符串、列表、字典、元组、集合、range)
1、range
range 内置类用来生成指定区间的整数序列
for i in range(1,10):
print(i)
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
三、for…else
for…else语句: 当循环中得break没有被执行时,就会执行else
如:
for i in rang(101,201):
for j in range(2,10):
if :
break
else:
xxxxx
break和continue
-
break:用来结束整个循环
-
continue: 用来结束本轮循环,开启下一轮循环
字符串
pythonASCII码与字符相互转换
print(ord('a')) #97
print(chr(97)) #a
字符串的下标和切片
字符串是不可变数据类型
下标
word = 'hello'
print(word[1]) #e
注意:
word[1] = x #为错误行为,不能更改字符串内容
切片
切片就是从字符串里复制一段指定内容,生产一个新的字符串
m[start🔚step ]
m = 'asdfghjkl'
print(m[1:6]) #sdfgh 只包含start,不包含end
print(m[1:6:2]) #sfh 每隔step-1个取一次
print(m[6:1:-1]) #jhgfd step取负数,表示从右向左获取
print(m[-8:-1]) #sdfghjk
字符串常见的操作
-
获取长度:len
-
查找内容:find、index、rfind、rindex
-
判断:startswith、endswith、isalpha、isalnum、isspace、isdigit
-
机算出现次数:count
-
替换内容:replace
-
切割字符串:split、rsplit、splitlines、partition、rpartition
-
修改大小写:capitalize、title、upper、lower
-
空格处理:ljust、rjust、center、lstrip、rstrip、strip
-
字符串拼接:join
x = 'qwertylp'
#获取字符串长度
print(len(x))
#查找内容相关的方法 find/index/rfind/rindex 可以获取指定字符的下标
print.(x.find('l')) #6 其他用法相同
#replace:用来替换字符串
word = 'hello'
m = word.replace('l','x')
print(word) #hello 因为在python中字符串是不可变数据类型
print(m) #hexxo
内容分割相关的操作
-
split方法,可以将一个字符串切割成一个列表(rsplit用法和它大致相同)
x = 'wang-ren-min-tian-di-ke-wei' y = x.split('-') print(y) #['wang', 'ren', 'min', 'tian', 'di', 'ke', 'wei'] print(x.split('-',2)) #['wang', 'ren', 'min-tian-di-ke-wei']
-
rsplit:
x = 'wang-ren-min-tian-di-ke-wei' y = x.split('-') print(y) #['wang', 'ren', 'min', 'tian', 'di', 'ke', 'wei'] print(x.rsplit('-',2)) #['wang-ren-min-tian-di', 'ke', 'wei']
-
partition:将指定一个字符串作为分隔符,分为三部分(rpartition用法和它大致相同)
print('asdfdghj'.partition('d')) #('as', 'd', 'fdghj') print('asdfdghj'.rpartition('d')) #('asdf', 'd', 'ghj')
修改大小写
-
capitalize:让第一个单词的首字母大写
print('hello'.capitalize) #Hello
-
upper:全大写
print('hello'.upper()) #HELLO
-
lower:全小写
print('WoRLd'.lower()) #world
-
title: 每个单词的首字母大写
print('good morning'.title()) #Good Morning
空格处理
-
ljust:向右补空格
# ljust(width,fillchar) width长度,fillchar填充字符,默认是空格 print('Monday'.ljust(10)) #Monday 在右边补了五个空格
-
rjust:与ljust类似
-
center:返回指定长度的字符串,并在两端使用空白字符补全(居中对齐)
print('hello'.center(10))# hello 两端加空格,让内容居中
-
lstrip:删除 x 左边的空白字符
x = ' he llo ' print(x.lstrip()) #he llo 只去掉左边,其余空字符保留
-
rstrip:删除 x 右边的空白字符
x = ' he llo ' print(x.lstrip()) # he llo只去掉右边边,其余空字符保留
将列表转换成字符串
fruits = ['apple','pear','peach','banana']
print('-'.join(fruits)) #apple-pear-peach-banana
字符集
-
ord:获取字符对应的编码
print(ord(a)) #字符对应的编码是 97
-
chr:根据编码获取对应的字符
print(chr(65)) #A
成员运算符
in和not in 运算符:用来判断一个内容在可迭代对象里是否存在
word = 'hello'
x = input('输入:')
if x in word:
print('存在')
else:
print('不存在')
if x not in word:
print('不存在')
else:
print('存在')
格式化打印字符串
在字符串中可以使用 % 占位符
-
%s表示的是字符串的占位符
-
%d表示的是整数的占位符
%nd打印时,显示n位,如果不够,在前面使用空格补齐
-
%f表示的是浮点数的占位符(默认6位小数)
%.nf打印时,表示显示n位小数
-
%x将数字使用十六进制输出
name = 'zhangshan'
age = 18
height = 183.0
print('大家好,我的名字是%s,今年%d岁,身高%.1f' % (name,age,height))
#大家好,我的名字是zhangshan,今年18岁,身高183.0
字符串的format方法的使用
-
{}:
x = '大家好,我是{},我今年{}岁'.format('张三',18) print(x)
-
{数字}:
y = '大家好,我是{1},我今年{0}岁了'.format(20,'张三') print(y)
-
{变量名}:
z = '大家好,我是{name},我今年{age}岁了,我来自{adder}'.format(age = 18,name = '张三',adder = '襄阳') print(z)
-
混合使用 {数字} {变量}:
a = '大家好,我是{name},我今年{1}岁了,我来自{0}'.format('泰国',23,name='tony') print(a) #注意:变量要放在后面
-
用列表:
d = ['zhangsan',18,'上海',180] b = '大家好,我是{},我今年{}岁了,我来自{},身高{}cm'.format(d[0],d[1],d[2],d[3]) #或者 b = '大家好,我是{},我今年{}岁了,我来自{},身高{}cm'.format(*d)
-
用字典:
info = {'name':'chris','age':'18','addr':'北京','height':190} c = '大家好,我是{name},我来自{addr},身高{height}cm,我今年{age}岁'.format(**info) print(c)
列表(list)
列表是用来保存多个数据的
列表的基本使用
-
基本表达:
name = ['张三','李四','王五'] print(name) #['张三', '李四', '王五']
-
用下标修改表里元素:
name = ['张三','李四','王五','马超','关羽'] name[3] = '花木兰' print(name) #['张三', '李四', '王五', '花木兰', '关羽']
-
用下标实现切片:
name = ['张三','李四','王五','马超','关羽'] print(name[1:4]) #['李四', '王五', '马超']
-
用下标获取元素:
name = ['张三','李四','王五','马超','关羽'] print(name[2]) #王五
列表的操作
操作列表,一般都包含增删改查数据
-
添加元素(append insert extend):
-
append(在列表的最后面追加一个数据):
heros = ['林青霞','王祖贤','张曼玉'] heros.append('张国荣') print(heros) #['林青霞', '王祖贤', '张曼玉', '张国荣']
-
insert(index,object):
heros = ['林青霞','王祖贤','张曼玉'] heros.insert(2,'吴彦祖') #['林青霞', '王祖贤', '吴彦祖', '张曼玉']
-
extend(iterable) 需要一个可迭代对象:
heros = ['林青霞','王祖贤','张曼玉'] x = ['刘德华','张学友'] heros.extend(x) print(heros) #['林青霞', '王祖贤', '张曼玉', '刘德华', '张学友']
-
-
删除数据 (pop remove clear):
-
pop:
默认删除列表最后一个元素,并且返回这个元素
heros = ['林青霞','王祖贤','张曼玉'] print(heros.pop()) #张曼玉
还可以传入index参数,用来删除指定位置上的数据
heros = ['林青霞','王祖贤','张曼玉'] print(heros.pop(0)) #林青霞
-
remove(指定删除对象):
heros = ['林青霞','王祖贤','张曼玉'] heros.remove('王祖贤') print(heros) #['林青霞', '张曼玉']
-
clear (用来清空一个列表) :
heros = ['林青霞','王祖贤','张曼玉'] heros.clear() print(heros) #[]
-
-
查询方法
-
index(查询位置):
Bf = ['林青霞','王祖贤','张曼玉'] print(Bf.index('王祖贤')) #1
-
count(查询数量个数):
Bf = ['张曼玉','林青霞','王祖贤','张曼玉'] print(Bf.count('张曼玉')) #2
-
in:
Bf = ['张曼玉','林青霞','王祖贤','张曼玉'] print('王祖贤' in Bf) True
-
-
修改元素
使用下标可以直接修改列表的元素
Bf = ['张曼玉','林青霞','王祖贤','张曼玉'] Bf[0] = '张国荣' print(Bf) #['张国荣', '林青霞', '王祖贤', '张曼玉']
-
复制
copy()
name_list = ['tom','jim','rose'] name_123 = name_list.copy() print(name_123) #['tom', 'jim', 'rose']
-
排序
sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数。
语法
list.sort( key=None, reverse=False)
- key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
- reverse – 排序规则,reverse = True 降序, reverse = False 升序(默认)。
实例
aList = ['Google', 'Runoob', 'Taobao', 'Facebook'] aList.sort() print ( "List : ", aList) # List : ['Facebook', 'Google', 'Runoob', 'Taobao']
列表的遍历
while
-
代码
name_list = ['tom','jim','rose'] i = 0 while i<len(name_list): print(name_list[i]) i += 1
for
-
代码
name_list = ['tom','jim','rose'] for i in name_list: print(i)
列表嵌套
-
代码
name_list = [['小明,小红'],['Tom','Jim']]
元组(tuple)
元组和列表非常相似,但是元组一旦被初始化就不能修改,所有没有append()、insert()这样的方法
定义元组
-
代码
#多个数据 name_list = ('tom','jim','bill') #单个数据 name_list = (1,)
注:定义单个元素的tuple,必须有 ’‘,’‘ 不然定义的不是tuple,是 1这个数
元组的常见操作
元组数据只支持查找,具体如下:
-
按下标查找
tuple1 = ('aa','bb','cc') print(tuple1[0]) #aa
-
index(): 查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串和index方法相同
tuple1 = ('aa','bb','cc') print(tuple1.index('aa')) #0
-
count(): 统计某个数据在当前元组的次数
tuple1 = ('aa','bb','cc','aa') print(tuple1.count('aa')) #2
-
len(): 统计元组中数据的个数
tuple1 = ('aa','bb','cc','aa') print(len(tuple1)) #4
元组数据的修改操作
元组里面有list,修改list里面的数据是支持的
tuple2 = (10,20,['aa','bb','cc'],40,30)
print(tuple2)
tuple2[2][0] = 'aaa'
print(tuple2)
#(10, 20, ['aa', 'bb', 'cc'], 40, 30)
#(10, 20, ['aaa', 'bb', 'cc'], 40, 30)
字典(dict)
key-value存储方式 一个key只能对应一个value
定义字典
-
代码
# 有数据字典 dict1 = {'name':'Tom','age':20,'gender':'男'} #空字典 dict2 = {} dict3 = dict()
字典常见操作
1、增
写法:字典序列[key] = 值
注:key存在即 修改key对应的值,key不存在则新增此键值对
dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1)
dict1['name'] = 'Jim'
print(dict1)
dict1['id'] = 110
print(dict1)
#{'name': 'tom', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男', 'id': 110}
注:字典为可变类型
2、删
-
del() / del:删除字典或删除字典中指定键值对
dict1 = {'name':'tom','age':20,'gender':'男'} print(dict1) del dict1['gender'] print(dict1) #{'name': 'tom', 'age': 20, 'gender': '男'} #{'name': 'tom', 'age': 20}
-
clear():请空字典
dict1 = {'name':'tom','age':20,'gender':'男'} dict1.clear() print(dict1) #{}
3、改
写法:字典序列[key] = 值
注:如果key存在则修改这个key对应的值,不存在则新增此键值对
dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1)
dict1['name'] = 'Jim'
print(dict1)
dict1['id'] = 110
print(dict1)
#{'name': 'tom', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男', 'id': 110}
4、查
4.1 key值查找
dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1['name']) #tom
print(dict1['id']) #报错
4.2 get()
-
语法
字典序列.get(key,默认值)
注意:如果当前查找的key不存在则返回第二个参数值(默认值),如果省略第二个参数值,则返回None
-
代码
dict1 = {'name':'tom','age':20,'gender':'男'} print(dict1.get('name')) print(dict1.get('id',-1)) print(dict1.get('id')) # tom # -1 # None
4.3 keys()
-
代码
dict1 = {'name':'tom','age':20,'gender':'男'} print(dict1.keys()) #dict_keys(['name', 'age', 'gender'])
4.4 values()
- 代码
dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1.values())
#dict_values(['tom', 20, '男'])
4.5 items()
-
代码
dict1 = {'name':'tom','age':20,'gender':'男'} print(dict1.items()) #dict_items([('name', 'tom'), ('age', 20), ('gender', '男')])
字典的循环遍历
语法 for…in….
遍历key
dict1 = {'name':'tom','age':20,'gender':'男'}
for i in dict1.keys():
print(i)
# name
# age
# gender
遍历value
dict1 = {'name':'tom','age':20,'gender':'男'}
for i in dict1.values():
print(i)
# tom
# 20
# 男
遍历字典的键值对
dict1 = {'name':'tom','age':20,'gender':'男'}
for i in dict1.items():
print(i)
#('name', 'tom')
#('age', 20)
#('gender', '男')
集合(set)
set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
注:创建空集合只能使用set(), 因为{}用来创建空字典
set不是有序的
创建集合
s1 = {10,20,30,40}
print(s1)
s2 = set('abcedfab')
print(s2)
s3 = set()
print(s3)
s4 = set([1,2,3,4,5])
print(s3)
# {40, 10, 20, 30}
# {'f', 'a', 'c', 'b', 'e', 'd'}
# set()
{1, 2, 3, 4, 5}
增加数据
-
add()
s1 = {10,20} s1.add(100) print(s1) s1.add(10) print(s1) #{100, 10, 20} #{100, 10, 20}
集合有去重功能,重复添加无效、且集合无序
- update(),追加的数据是序列
序列类型包括字符串、列表、元组、集合和字典
s1 = {1,2,3,4}
s1.update('abcdef')
print(s1)
# {'b', 1, 2, 3, 4, 'd', 'c', 'e', 'f', 'a'}
删除数据
-
remove(), 删除集合中指定元素,元素不存在则报错
s1 = {2,3,4,5} s1.remove(3) print(s1) # {2, 4, 5}
-
discard(), 删除集合中的指定元素,元素不存在不报错
s1 = {2,3,4,5} s1.discard(6)
-
pop(), 随机删除集合中的某个元素,并返回该元素
s1 = {2,3,4,5} print(s1.pop()) print(s1) # 2 # {3, 4, 5}
查找元素
-
in:判断元素在集合序列
-
not in:判断元素不在集合序列
s1 = {'a','b','c','d'} print('a' in s1) print('e' not in s1 ) # True # True
公共的方法
一、运算符
运算符 | 描述 | 支持的容器类型 |
---|---|---|
+ | 合并 | 字符串、列表、元组 |
* | 复制 | 字符串、列表、元组 |
in | 元素是否存在 | 字符串、列表、元组、字典 |
not in | 元素是否不存在 | 字符串、列表、元组、字典 |
二、公共方法
函数 | 描述 |
---|---|
len() | 计算容器中元素的个数 |
del() 或del+空格 | 删除 |
max() | 返回容器中元素最大值 |
min() | 返回容器中元素最小值 |
range(start,end,step) | 生成从start到end的数字,步长为step,供for循环使用 |
enumerate() | 函数用于将一个可便利的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用于 for 循环当中 |
-
del /del()
s1 = [1,2,3] s2 = [4,5,6] del s1 del(s2)
-
range()
for i in range(1,10): print(i,end=' ') # 1 2 3 4 5 6 7 8 9 for i in range(1,10,2): print(i,end=' ') # 1 3 5 7 9 for i in range(10): print(i,end=' ') # 0 1 2 3 4 5 6 7 8 9
-
enumerate()
1、语法
enumerate(可遍历对象,start=0)
注意:start参数用来设置遍历数据的下标的起始值,默认为0
2、代码
list1 = ['a','b','c','d'] for i in enumerate(list1): print(i) for index,char in enumerate(list1,start=1): print(index,char) # (0, 'a') # (1, 'b') # (2, 'c') # (3, 'd') # 1 a # 2 b # 3 c # 4 d
函数
在python里的变量,函数和模块名使用下划线连接;类名使用大驼峰命名法
如:user_name_and_password
-
函数的作用:封装代码,高效的代码使用
-
函数使用步骤
-
定义函数
def 函数名(): 代码1 代码2 ...
-
调用函数
函数名
-
-
函数的参数:函数调用的时候可以传入真实数据,增大函数使用的灵活性
- 形参:函数定义时书写的参数(非真实数据)
- 实参:函数调用时书写的参数(真实数据)
-
函数的返回值
-
作用:函数调用后,返回需要的计算结果
-
写法
return 表达式
-
-
函数的说明文档
-
作用:保存函数解释说明的信息
-
写法
def 函数名() """ 函数说明文档 """"
-
-
函数嵌套调用:一个函数内部嵌套调用另一个函数
函数的提高
变量作用域
变量作用域指变量生效的范围,主要分为两类:局部变量和全局变量
- 局部变量
定义在函数内部的变量,即只在函数内部生效
def testA():
a = 1
print(a)
testA() #1
testA(a) #NameError: name 'a' is not defined
变量a是定义在 test函数 内部的变量,在函数外部访问则立即报错
局部变量的作用:在函数体内部,临时保存数据,即当函数调用完成后,则销毁局部变量
- 全部变量
在函数体内、外都能生效的变量
#定义全局变量a
a = 100
def testA():
print(a)
def testB():
print(a)
testA() #100
testB() #100
-
在函数体内部修改全局变量
a = 100 def testA(): print(a) def testB(): # global 关键字声明a是全局变量 global a a = 200 print(a) testA() testB() print(f'全局变量a = {a}') # 100 # 200 # 全局变量a = 200
多函数程序执行流程
-
公用全局变量
# 1、定义全局变量 gol_num = 0 def test1(): global gol_num # 修改全局变量 gol_num = 99 def test2(): # 调用test1函数中修改后的全局变量 print(gol_num) # 2、调用test1函数,执行函数内部代码:声明和修改全局变量 test1() # 3、调用test2函数、执行函数内部代码,打印 test2() #100
-
返回值作为参数传递
def test1(): return 99 def test2(num): print(num) test2(test1())
函数的返回值
- 一个函数返回多个函数值
def return_num():
return 1,2
result = return_num()
print(return_num())
#(1, 2)
注意:
1、return a ,b 写法,返回多个数据时,默认为元组
2、return后面可以连接列表、元组或者字典,以返回多个值
函数的参数
位置参数
位置参数:调用函数时根据函数定义的参数位置来传递函数
def user_info(name,age,gender):
print(f'您的名字是{name},年龄{age},性别是{gender}')
user_info('Tom',18,'男')
#您的名字是Tom,年龄18,性别是男
注意:传递和定义参数的顺序及个数必须一致
关键字参数
函数调用,通过“key = value”形式加以指定。可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。
def user_info(name,age,gender):
print(f'您的名字是{name},年龄{age},性别是{gender}')
user_info(name='王祖贤',gender='女',age=20)
# 您的名字是王祖贤,年龄20,性别是女
注意:函数调用时,如果有位置参数时,位置参数必须在关键字的前面,但关键字参数之间不存在先后顺序
缺省参数
缺省参数也叫默认参数,用于定义函数,为函数提供默认值,调用函数时可不传该默认参数的值(注:所有位置参数必须在默认参数前,包括函数定义和调用)
def user_data(name,age,gender = '男'):
print(f'你的名字是{name},年龄是{age},性别是{gender}')
user_data('Tom',30)
user_data('王祖贤',20,'女')
# 你的名字是Tom,年龄是30,性别是男
# 你的名字是王祖贤,年龄是20,性别是女
注意:函数调用时,如果为缺省参数传值则修改默认参数值;否则使用该函数值
不定长参数
不定长参数也叫可变参数,用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时,可用包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会显得非常方便
- 包裹位置参数
def user_info(*args):
print(args) #args不是固定形参,是常用
user_info('Tom')
user_info('Tom',18,'王祖贤')
# ('Tom',)
# ('Tom', 18, '王祖贤')
注意:传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是包裹位置传递。
- 包裹关键字传递
def user_info(**kwargs):
print(kwargs)
user_info(name='tom',age=20,gender='男')
#{'name': 'tom', 'age': 20, 'gender': '男'}
综上,无论是包裹位置传递还是包裹关键字传递,都是一个组包的过程。
拆包和交换变量值
拆包
-
拆包:元组
def return_num(): return 300,400 num1, num2 = return_num() print(num1) # 300 print(num2) # 400
-
拆包:字典
交换变换量值
需求:交换a ,b两个变量的值
- 方法一
借助第三方变量存储数据
a = 10
b = 20
c = a
a = b
b = c
print(a) #20
print(b) #10
- 方法二
a,b = 1,2
a,b = b,a
print(a) #2
print(b) #1
引用
了解引用
在python中,值是靠引用来传递来的。
我们可以用id()来判断两个变量是否为一个值的引用。我们可以将id值理解为那块内存的地址标识。
- int类型
a = 1
b = a
print(b) #1
print(id(a)) #2202015263024
print(id(b)) #2202015263024
a = 2
print(b) #1 ,说明int类型是不可变类型
print(id(a)) #2202015263056
print(id(b)) #2202015263024
- list类型
aa = [10,20]
bb = aa
print(id(aa)) #1612505953280
print(id(bb)) #1612505953280
aa.append(30)
print(bb) #[10, 20, 30],列表为可变类型
print(id(aa)) #1612505953280
print(id(bb)) #1612505953280
引用当做实参
代码如下:
def test1(a):
print(a)
print(id(a))
a += a
print(a)
print(id(a))
#int:计算前后id不同
b = 100
test1(b)
#list:计算前后id相同
c = [10,20]
test1(c)
结果如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OvZUZhAu-1617806463940)(C:\Users\86182\AppData\Roaming\Typora\typora-user-images\image-20210325145406398.png)]
可变和不可变类型
数据能够直接修改是可变类型,不可修改的是不可变类型
即:地址是否改变,改变的是不可变
- 可变类型
- 列表
- 字典
- 集合
- 不可变类型
- 整型
- 浮点型
- 字符串
- 元组
lambda表达式
lambda也是一个匿名函数
lambda的应用场景
如果一个函数有一个返回值,并且只有一句代码,可以用lambada简化
lambda语法
lambda 参数列表:表达式
注意
- lambda表达式的参数可有可无,函数的参数在lambda表达式中完全适用
- lambda表达式能接受任何数量的参数但只能返回一个表达式的值
def fnl():
return 100
print(fnl())
#lambda实际也是一个匿名函数
fnl1 = lambda:100
print(fnl1)
print(fnl1())
#100
# <function <lambda> at 0x0000020BD25EA310>
# 100
直接打印lambda表达式,输出的是内存地址
示例:计算a + b
1、函数实现
def add(a,b):
return a,b
print(add(1,2))
2、lambda实现
fnl = lambda a, b:a + b
print(fnl(1,2))
lambda的参数形式
1、无参数
fn0 = lambda: 100
print(fn0())
2、一个参数
fn1 = lambda a: a
print(fn1(1))
3、默认参数
fn2 = lambda a, b, c = 100: a + b + c
print(fn2(100,100))
4、可变参数:*args
fn3 = lambda *args: args
print(fn3(1,2,3,4,5))
#生成元组
5、可变参数:**kwargs
fn4 = lambda **kwargs: kwargs
print(fn4(name = 'tom',age = 20))
#生成字典
lambda的应用
1、带判断的lambda
fnl = lambda a,b:a if a > b else b
print(fnl(10,20))
# 20
2、列表数据按字典key的值排序
students = [{'name':'Tom','age':18},{'name':'jim','age':19}, {'name': 'Rose', 'age':20}]
#按age值升序排列
students.sort(key=lambda x:x['age'])
print(students)
#按age值降序排列
students.sort(key=lambda x:x['age'],reverse=True)
print(students)
高阶函数
把函数当作参数传入,这样的函数称为高阶函数,高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式
体验高阶函数
-
abs()函数
可以对数字求绝对值计算
abs(-10) #10
-
round()函数
可以对数字完成四舍五入计算
print.(round(1.2)) #1 print.(round(1.9)) #2
例子:对两个数进行加法
def sum_num(a,b,f):
return f(a)+f(b)
print(sum_num(3,-3,abs))
#6
内置的高阶函数
1、map()
map(func,lst),将传入的函数变量func作用到lst变量的每个元素中,并将结果组成新的迭代器返回
例子:计算list1序列中各个数字的二次方
def func(x):
return x ** 2
list1 = [1,2,3,4]
result = map(func,list1)
print(result)
print(list(result))
# <map object at 0x000001FB6894CFA0>
# [1, 4, 9, 16]
2、reduce()
reduce(func,lst),其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算
注意:reduce()传入的参数func必须接收两个参数
例子:计算list1序列中各个数字的累加和
import functools
list1 = [1,2,3,4,5]
def func(a,b):
return a + b
result = functools.reduce(func,list1)
print(result)
# 15
3、fileter()
fileter(func,lst)函数用于过滤序列,过滤掉不符合条件的元素,返回一个filter对象。如果要转换为列表,可以用list()来转换
list1 = [1,2,3,4,5,6,7,8]
def func(x):
return x % 2 == 0
result = filter(func,list1)
print(result) # <filter object at 0x00000162AB5CCFA0>
print(list(result)) #[2, 4, 6, 8]
文件
文件备份
步骤
1、接受用户输入的文件名
2、规划备份文件名
3、备份文件写入数据
代码实现
1、接受用户输入目标文件名
old_name = input('请输入您要备份的文件名')
2、规划备份文件名
2.1 提取目标文件后缀
2.2 组织备份的文件名,xx[备份]后缀
# 2.1 提取文件后缀点的下标
index = old_name.rfind('.')
# 2.2 组织新文件名 旧文件名 + [备份] + 后缀
new_name = old_name[:idex] + '[备份]' + old_name[index:]
#打印新文件名 (带后缀)
print(new_name)
3、备份文件写入数据
3.1 打开源文件 和 备份文件
3.2 将源文件数据写入备份文件
3.3 关闭文件
# 3.1 打开文件
old_f = open(old_name,'rb')
new_f = open(new_name,'wb')
#3.2 将源文件数据写入备份文件
while True:
con = old_f.read(1024)
if len(con) == 0:
break
new_f.wirte(con)
# 3.3 关闭文件
old_f.close()
new_f.close()
—————————–
面向对象:
类和对象:
类和对象的关系:用类去创造一个对象
定义类:
-
语法
class 类名(): 代码 ......
注意:类名要满足标识符命名规则,同时遵循大驼峰命名习惯
-
体验
class User: def __init__(self,first_name,last_name,gender,age): self.first_name = first_name self.last_name = last_name self.gender = gender self.age = age self.login_attempts = 0 def decribe_user(self): print(f"姓名{self.first_name}{self.last_name},年龄{self.age},性别{self.gender}") def greet_user(self): print('为您服务') def increment_login_attempts(self): self.login_attempts += 1 def reset_login_attempts(self): self.login_attempts = 0 def print_login_attempts(self): print(f"{self.login_attempts}")
继承
父类必须包含在当前文件,且位于子类前面
-
代码
class User: ...... ...... class Admin(User): def __init__(self,first_name,last_name,gender,age): super().__init__(first_name,last_name,gender,age) self.privileges = Privileges()
:
return a + b
result = functools.reduce(func,list1)
print(result)
15
#### 3、fileter()
fileter(func,lst)函数用于过滤序列,过滤掉不符合条件的元素,返回一个filter对象。如果要转换为列表,可以用list()来转换
```python
list1 = [1,2,3,4,5,6,7,8]
def func(x):
return x % 2 == 0
result = filter(func,list1)
print(result) # <filter object at 0x00000162AB5CCFA0>
print(list(result)) #[2, 4, 6, 8]
文件
文件备份
步骤
1、接受用户输入的文件名
2、规划备份文件名
3、备份文件写入数据
代码实现
1、接受用户输入目标文件名
old_name = input('请输入您要备份的文件名')
2、规划备份文件名
2.1 提取目标文件后缀
2.2 组织备份的文件名,xx[备份]后缀
# 2.1 提取文件后缀点的下标
index = old_name.rfind('.')
# 2.2 组织新文件名 旧文件名 + [备份] + 后缀
new_name = old_name[:idex] + '[备份]' + old_name[index:]
#打印新文件名 (带后缀)
print(new_name)
3、备份文件写入数据
3.1 打开源文件 和 备份文件
3.2 将源文件数据写入备份文件
3.3 关闭文件
# 3.1 打开文件
old_f = open(old_name,'rb')
new_f = open(new_name,'wb')
#3.2 将源文件数据写入备份文件
while True:
con = old_f.read(1024)
if len(con) == 0:
break
new_f.wirte(con)
# 3.3 关闭文件
old_f.close()
new_f.close()
—————————–
面向对象:
类和对象:
类和对象的关系:用类去创造一个对象
定义类:
-
语法
class 类名(): 代码 ......
注意:类名要满足标识符命名规则,同时遵循大驼峰命名习惯
-
体验
class User: def __init__(self,first_name,last_name,gender,age): self.first_name = first_name self.last_name = last_name self.gender = gender self.age = age self.login_attempts = 0 def decribe_user(self): print(f"姓名{self.first_name}{self.last_name},年龄{self.age},性别{self.gender}") def greet_user(self): print('为您服务') def increment_login_attempts(self): self.login_attempts += 1 def reset_login_attempts(self): self.login_attempts = 0 def print_login_attempts(self): print(f"{self.login_attempts}")
继承
父类必须包含在当前文件,且位于子类前面
-
代码
class User: ...... ...... class Admin(User): def __init__(self,first_name,last_name,gender,age): super().__init__(first_name,last_name,gender,age) self.privileges = Privileges()