函数的基础知识

m0_51482664

已于 2023-07-16 15:30:13 修改

阅读量56

点赞数

分类专栏：函数自动化文章标签： python 深度学习

于 2023-02-02 14:30:42 首次发布

本文链接：https://blog.csdn.net/m0_51482664/article/details/128849847

版权

自动化同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

函数

1 篇文章 0 订阅

订阅专栏

一、索引

Python中的索引
定义：我们可以直接使用索引来访问序列中的元素，
同时索引可分为正向和负向两种.
str=‘abcdef’
print str[2]-----------------------正索引
print str[-1]----------------------负索引

二、切片

Python中的切片
定义：切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[a : b : step]-------------a起始索引,b结束索引,step表示步长值，range是逗号隔开
例如：
str=‘abcdefghjkl’
print str[2:]---------------------------------------------------#cdefghjkl
print str[1:6:3]----------------------------------------------#be
print str[::1] -------------------------------------------------#abcdefghjkl
print str[::-1]：反转输出面试题常遇---------------------#lkjhgfedcba

字符串是 Python 中最常用的数据类型。我们可以使用引号’()'来创建字符串。

三、字符串常用函数

1.capitalize（）：首字符大写
a=‘hello’
print a.capitalize()
a=‘hello’------------------------#Hello

2.count()：统计具体字符出现的次数
a=‘adfafdafd’
print a.count(‘a’)------------------#3

3.join()：把集合中的字符按自定义的分隔符连接在一起
a =‘hello’ ---------------------------#定义一个字符串
print ''.join(a)---------------------#hell*o

4.split()：把字符串通过指定标识符进行分割
a =‘hello’ ---------------------------#定义一个字符串
print a.split(‘e’)-------------------- [‘h’, ‘llo’]

5.strip(ab)：------------------------删除字符串开头和结尾有a或b的字符
a =‘hello’----------------------------定义一个字符串
print a.strip(‘lo’) -------------------#he

6.lstrip(ab)：-----------------------删除字符串开头有ab序列字符
a =‘hello’---------------------------- #定义一个字符串
print a.lstrip(‘h’)------------------- #ello 删除开头的如不匹配则返回完整结果

7.rstrip(ab)：-----------------------删除字符串结尾有ab序列字符
a =‘hello’ ----------------------------
print a.rstrip(‘lo’) -------------------#he 删除结尾的如不匹配则返回完整结果

8.startswith()：---------------------判断字符串是否以什么开始
a =‘hello’----------------------------- ## 定义一个字符串定义一个字符串
print a.startswith(‘he’) -------------#True 带有判断性质的函数或者方法返回的一般都是布尔值：True

9.endswith()：-----------------------判断字符串是否以什么结束
a=‘hello’-------------------------------# 定义一个字符串
print a.endswith(‘l’)-----------------#false 布尔值显示

10.find()/rfind()：------------------字符串查询find()是左边开始查,rfind()从右边开始查，结果显示下标
a=‘heleleo’--------------h e l e l e o
0 1 2 3 4 5 6
print a.find(‘e’)----------------------1,左边取第一个e,索引值为1
print a.rfind(‘e’)---------------------5,右边取第一个e,索引对应的值为5

11.replace()：replace(substring,newstring,max)
substring表示被替换的字符串,newstring要替换字符串,max表示替换的次数
a =‘heleleoe’
print a.replace(‘e’,‘t’) ---------------#htltltot
print a.replace(‘e’,‘t’,3) ------------#htltltoe

12.lower()：方法转换字符串中所有大写字符为小写
a =‘234HELaL1O’
print a.lower() ------------------------#234helal1o

13.upper()：将字符串中的所有小写字符转换为大写字母输出
a =‘a123hello’
print a.upper()------------------------#123HELLO

14.isdigit()：判断字符串中是否全为数字
a =‘hel123456’
print a.isdigit() -----------------------#False
a =‘123456’
print a.isdigit()------------------------ #True

15.isalpha()：判断字符串中是否全为字母
a =‘Hello123’
print a.isalpha()--------------------- #False
a =‘Hleleo’
print a.isalpha() ----------------------#True

16.isalnum()：判断字符串当中全都为数字，全为字母，或者全为字母数字都可以是 True 否False ，如果有特殊符号就是否
a =‘1235567’
print a.isalnum() ----------------------#True
a =‘dsafdsafdsa’
print a.isalnum()----------------------- #True
a =‘HELLO’
print a.isalnum() ----------------------#True
a=‘heloo123’
print a.isalnum()----------------------- #True

a=‘hell12,’

print a.isalnum()---------------------#Falsed（有，号，特殊符号）

17.istitle()：判断字符串中英文单词首字母是否为大写，其他是否为小写
a =‘Hello’
print a.istitle()--------------------------- #True
a =‘H1234’
print a.istitle() ---------------------------#True
a =‘asdf’
print a.istitle() ----------------------------#False
a =‘H’
print a.istitle() ----------------------------#True

18.isupper（）/islower（）:is开头的就是判断一个字符串是否展示为都是大写或者都是小写

isupper（） #判断当前字符串中是否全部为大写(不能包含大小写，可以包含其它字符
print a.isupper()------------------------ #False
a =‘helos’
print a.isupper()------------------------ #False
a =‘HLLEOS’
print a.isupper() ------------------------#True
a =‘HLHLH*’
print a.isupper()-------------------------#True
a =‘HADS123’
print a.isupper() ------------------------#True

19.islower()判断当前字符串中是否全部都为小写，如大小写包含则返回False，其它则True
a =‘Hdsafds’
print a.islower() ---------------------------#False
a =‘sdfadsf’
print a.islower()----------------------------#True
a =‘afdda12321’
print a.islower()---------------------------- #True

四、Python中的列表

定义：列表（List）是一组有序存储的数据

1.列表基础知识

列表表达符为：[]

方式一：a = [1,2,3,4] --------------------#直接通过’[]'进行定义–查询类型print type(l_ist) --#<type ‘list’>
l_ist =[1,23,4,“tset”]
print l_ist #[1, 23, 4, ‘tset’]---------------查询字符类型–print type(l_ist) —#type ‘list’>

方式二：userlist =list(‘1234’) —#使用list（）进行定义–转换（定义的变量名称尽量不要和类型名称相同）
a =‘12’ ------------------#定义一个字符串--------print type(a) ------#<type ‘str’>字符串类型
l_ist =list(a) -----------#通过list将a字符串转换成为了列表
print l_ist #[‘1’, ‘2’]----#[‘1’, ‘2’]-----完成之后查询print type(l_ist)----- #type ‘list’>

2.列表常见操作：

列表：
l=[1,7,4,6,5,8,]
1)l.sort(): 将列表按照升序进行排序（从小到大）
l.sort()
print l-------------------#[1, 4, 5, 6, 7, 8]

2)sorted():实现降序排序
sorted(l,reverse=Ture)
sorted(l.reverse=False)
l=[1,7,4,6,5,8,]
print sorted(l,reverse=Ture)----------#[8, 7, 6, 5, 4, 1]
print sorted(l,reverse=False)---------#[1, 4, 5, 6, 7, 8]
reverse():列表反向输出list.reverse()----对字符串反向输出[::-1]

l=[1,7,4,6,5,8,]
3( l.pop(0)--------------------------------# 1
print l ----------------------------------------# [7,4,6,5,8,]

4)insert(index,value)：--------在指定位置插入一条数据
l=[1,7,4,6,5,8,]
l.insert(0,‘test’)-------------------插入一条数据
print l-------------------------------#[‘test’, 1, 7, 4, 6, 5, 8]

5)索引赋值(改变值)：
l=[1,7,4,6,5,8,]
l[0]=‘test1’-----------------------索引赋值
print l-----------------------------#[‘test1’, 7, 4, 6, 5, 8]

6)remove()：
l=[1,7,4,6,5,8,]
l.remove(7)--------------------移除整形数字7
print l----------------------------#[1, 4, 6, 5, 8]

l=[1,7,4,6,5,8,]
7）del l[0]--------------------------删除索引为0的参数
print l---------------------------#[7, 4, 6, 5, 8]

8）更改列表中的具体值
l=[1,7,4,6,5,8,]--------------定义列表
l[2] = list(‘56’)---------------更改索引为2的参数
print l--------------------------#[1, 7, [‘5’, ‘6’], 6, 5, 8]
l[2:] = list(‘56’)--------------索引2以后的元素更改
print l-------------------------#[1, 7, ‘5’, ‘6’]
（在列表里面添加字符串用insert(index,str),或者str()）

9)列表中文打印乱码解决方法
a = [1,2,3,“中国”]
print a---------------------------------------#[1, 2, 3, ‘\xe4\xb8\xad\xe5\x9b\xbd’]–乱码
print str(a).decode(‘string_escape’)—#[1, 2, 3, ‘中国’]---------decode（）：指定编码格式； -----------------------------------------------------------------------string-escape：编码格式，能解决因为被\转义问题

10）添加一个元素
l=[1,7,4,6,5,8,]
l.append(‘test’)-----------------添加一个元素
print l----------------------------#[1, 7, 4, 6, 5, 8, ‘test’]–一般默认末尾添加

11）连接两个列表
a =[1,2,3,4,5]
b =[6,7,8]
a.extend(b)--------------------------------b添加到a,b在末尾
print a---------------------------------------#[1, 2, 3, 4, 5, 6, 7, 8]
字符串定义：单引号，双引号，类型str

五、元组

可以理解为不可以被修改的列表，和列表一样有相应的切片，字符串相加可以拼接等功能

1）元组与列表之间的互换

2）元组的转换可以间接实现（通过转成列表完成操作再转成元组）

3）元组和列表的区别

4）当元组只有一个值末尾要加逗号

六、字典

定义：字典的每个键值对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
定义方式1：d={‘a’:1,‘b’:2}-------------通过{}直接定义
方式2：a= [(2,‘a’),(1,‘b’),(3,‘c’)]
d=dict(a)------------------通过dict()方法定义-
字典的常见操作

1)字典的遍历：for…in…遍历字典
d_ict={‘name’:‘zhnagsan’,‘age’:18}--------------------------直接定义字典
print d_ict
a=[(‘name’,‘zhangsan’),(‘’,‘lisi’),(‘age’,18)]--------------转录定义字典–print type(a)—<type ‘list’>
print type(a)--------------------------------------------------------查看字符类型<type ‘list’>
d_ict=dict(a)
print d_ict-----------------------------------------------------------转录定义字典（通过dict()方法定义）
d={‘name’:‘zhang’,‘age’:18}
print d.values()-------------------------第一种方法只能打印值----#[18, ‘zhang’]
c=d.values()
print c------------------------------------第一种方法只能打印值----#[18, ‘zhang’]
c=d.values()-----------------------------print type(d.values())-----#<type ‘list’>
a={‘name’:‘zhang’,‘age’:18}

2)del a---------------------------------------------------删除a字典
print a---------------------------#NameError: name ‘a’ is not defined,因为a字典被删除了
a={‘name’:‘zhang’,‘age’:18}
del (a[‘name’])
print a-----------------------------#{‘age’: 18},删除键，对应的值也删除
del (a[‘zhang’])
print a-------------------------------#KeyError: 'zhang 不能删除键对应的值，只能删除键

3)clear()清空字典所有项
dict = {‘name’:‘xiaoqian’,‘age’:18,‘hobby’:‘chifan’}
dict.clear()
print dict-------------------------------------#{},变成空字典
4)使用for…in…完成遍历
d ={‘name’:‘zhang’,‘age’:18}

for i in d:
print i,--------#age name -----只能显示对应的键的内容，不显示值（values只能显示对应的值）
d ={‘name’:‘zhang’,‘age’:18}

for i in d:
print i,d[i]----------------------------------------#age 18 name zhang

4）.dict1[‘sex’]=1----------------------------------------添加键值对，如果字典里已经有这个键,旧数据将会替换
print dict1--------------------------{‘age’: ‘10’, ‘name’: ‘xiaochen’, ‘sex’: 1}

dict1 = {‘name’:‘xiaoqian’,‘age’:18}
5.1)dict1.setdefault(‘sex’,‘1’)—插入键已经在字典里,插入是不生效的,默认值为空时,插入数据为None
print dic11---------------------#{‘age’: 18, ‘name’: ‘xiaoqian’, ‘sex’: ‘1’}
2)dict1.setdefault(‘name’,‘1’)
print dic11 -------------#{‘name’:‘xiaoqian’,‘age’:18}----------插入键已经在字典里,插入是不生效的

dict1 = {“name”:“xiaochen”,“age”:“10”}
1)print dict1.keys()--------------------------------------------#[‘age’, ‘name’]-----------取出键

dict1 = {“name”:“xiaochen”,“age”:“10”}

2)print dict1.values()-----------------------------------------#[‘10’, ‘xiaochen’]--------取出值
dict1 = {“name”:“xiaochen”,“age”:“10”}

3)print dict1[‘name’]------------------------------------------#xiaochen-----------取出具体键的值
d_ict={‘name’:‘zhnagsan’,‘age’:18}
for i in d_ict:------------------------------------------------for…in…(遍历字典)
print i，------------------------------------------------------#age name------得到的是当前字典的键

6.使用items()完成遍历
d={‘name’:‘zhnagsan’,‘age’:18}
1)for k,v in d.items():---------------------#通过items来取出字典中的键和值
print k,v,----------------------------#age 18 name zhnagsan
d={‘name’:‘zhnagsan’,‘age’:18}

2)for k in d.items():-----------------------#通过items来取出字典中的键和值,k可以换成v或者看k，v

print k,------------------------------#(‘age’, 18) (‘name’, ‘zhnagsan’)

d = {‘name’:‘xiaoqian’,‘age’:18,}
for key in d:
print “d[%s]=” % key,d[key],-----#d[age]= 18 d[name]= xiaoqian—"%key"对应的建，“dic22[key]”对应键的值

7.fromkeys：可以给具体的键指定值
d={‘name’:‘zhang’,‘age’:18}
1)print {}.fromkeys([‘name’,‘age’])-------#{‘age’: None, ‘name’: None},没有赋值默认None

d={‘name’:‘zhang’,‘age’:18}
2)print {} .fromkeys([‘name’,‘zhangsan’],‘test’,)–#{‘zhangsan’: ‘test’, ‘name’: ‘test’}-给两键同时加test

dict = {‘name’:‘xiaoqian’,‘age’:18,‘hobby’:‘chifan’}
3)print dict.get(‘name’)----------#xiaoqian（get(key)方法,通过key获取值,当键不存在,返回None）

dict = {‘name’:‘xiaoqian’,‘age’:18,‘hobby’:‘chifan’}
4)print dict.has_key(‘name’)-#true（has_key(),检查字典是否有指定的键,有返回True,没有返回False）

dict = {‘name’:‘zhang’,‘age’:18}
5)a=dict.popitem()-----popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)
print a----------------#(‘age’, 18)

6)update()利用一个字典项更新另外一个字典
a= {‘name’:‘zhang’,‘age’:18}
b={‘score’:89}
a.update(b)
print a----------------#{‘age’: 18, ‘score’: 89, ‘name’: ‘zhang’}

七、函数

1）函数中无参数：

def fun():-----------------------------------------------fun：函数名

print ‘duoceshi51’--------------------------------函数体

fun()-----------------------------------------调用函数------------#duoceshi51------------参数列表可以为空

2）函数中单个参数：

def fun1(str1):------------------------------------#fun1：函数名；str1：形参参数1

print str1+12------------------------------------------------函数体，12为实参

fun1(2)--------------调用函数----------#14-------------单个参数

fun()

def fun1(str1):

print 12

fun1(2)----------------------------#12–形参str1在当前代码中没有被引用，调用不会引用形参里面的结果

3）函数中多个参数：

def fun2(sum1,sum2):

print sum1+sum2

fun2(1,3)----------------------------------调用函数--------#4-----------------------定义的多个参数

4）定义带上默认参数函数（缺省参数）

def fun3(str=“深圳多测师”):

print str

fun3()-------------------------------------------------------#深圳测试----------------定义时带上默认参数

fun3(“广州多测师”)----------------------------------------#广州测试----

5）通过参数决定其打印内容

def fun1(str)

print str

fun1(“欢迎来到多测师”)------调用函数的往函数中的参数传值—#欢迎来到多测师

通过参数决定其打印内容

def fun2(sum1,sum2):

print sum1+sum2

fun2(1,3)-------------------------调用函数--------------#4

6）形参也可以直接赋予实参

def fun（name=‘zhangsan’,age=18）:

print name

fun()-------------------------#zhangsan------------此时调用函数可以不需要额外赋予实际参数，可变长元组和字典定义时也不需要赋予对应的实参，只有单个形参且没有赋予实参在调用函数时需要赋予实参

八、集合

1)set =可变集合(列表和字符串都可以转集合)

s_tr=‘hello’-----------------------------------------------定义一个字符串

a=set(s_tr)

print a ------------------------------------------------------# set([‘h’, ‘e’, ‘l’, ‘o’])

2)集合的添加add（），去除remove（），删除pop（）

l=[1,4,2,1,5]---------------------------------------------定义一个列表

a=set(l)--------------------------------------------------列表转集合

print a----------------------------------------------------#set([1, 2, 4, 5])

a.add(‘test’)--------------------#set([‘test’, 1, 2, 4, 5])–添加成功

print a.pop()------------------#1–返回当前删除值

a.remove(4)---------print a-----#set([1, 2, 5])—(移除不能print a.remove()4)

3)frozenset 不可变集合----------与set两者都可以去重，无法add，remove，pop

s_tr =‘hello’-----------------------------------------------定义一个字符串

print.a =set（s_tr）通过set可变集合对列表进行去重转换------#[‘h’,‘e’,‘l’,‘0’]----<type ‘set’>

print.a =frozenset（s_tr）通过不可变集合对当前字符串进行转译和去重-------<type ‘frozenset’>

class A：–定义一个类 ------如果当前函数是定义在类中;叫方法

def fun(self):---------fun叫方法

pass-------------站位

fun（）---------------------------------一个形参对应一个实参

6）可变长元组

def fun（*name）：

print name

(print type(name)---------------<type ‘tuple’>)

fun(‘test’,‘hello’)------------------#(‘test’, ‘hello’)-----调用函数本身对应形参可赋予多个实参

def fun（**name）：

print type(name)---------<type ‘dict’>

fun(age=18，score=100)--------------------{‘age’: 18，‘score’：100}----变成字典形式

a={‘name’:18}

def fun2（**name）：

for i in name.items():

print i,

print type(i)-------------------------#(‘name’, 18)---------<type ‘tuple’>

fun2（**a）

a={‘name’:18}

def fun2(**name):

for i,k in name.items():

print i,k,

print type(i)-------------------------------<type ‘str’>

fun2(**a),----------------#name 18---------------输出键值变量—类型<type ‘str’>

例子2

def fun(*name,**age):

print name,age

dic={“name”:“xiaowang”,“age”:18}

fun(dic)----------------------------------------#() {‘age’: 18, ‘name’: ‘xiaowang’}—字典加

def fun(*name,**dic):----------可变长元组和可变长字典同时存在，可变长元组在前

def fun(*name,**value):--------------定义一个定义一个可变长元组和可变长字典

print name,--------------------------逗号可以让元组和字典在同一行

print value

fun(, “daqian”, “xiaowang”, name=“xiaoqian”, age=“18”)----#( ‘daqian’, ‘xiaowang’) {‘age’: ‘18’, ‘name’: ‘xiaoqian’}，变成一个字典和一个元组，数字可以不加引号，加了不是表示数字了

（赋予的不是可变长，调用函数需要赋予形参对应的实参，可变长的则不需要赋予实参也能执行）

九、函数的变量和作用域

局部变量-------------------------函数内部变量

全局变量-------------------------函数外部变量

num=100

def fun():

num=50 -------------------------------------------------#局部变量

print num -----------------------------------------------#打印局部变量

fun() -----------------------------------------------------------#函数调的是局部变量

print num----------------------------------------------------- #打印全局变量

num=100

def fun():

x = num+100 -------------#引用全局变量（函数内部的变量名=符号后面出现被定义为全局变量）

print x---------------------------#200

fun()

print num----------------------------#100

num=100

def fun():

global num-------声明成一个全局变量（函数中将某个变量定义为全局变量时需用关键字global）

num=200

print num-----------------------------#200

fun()

print num----------------------------------#200

def fun():---------------------------------定义一个函数

num=100

a =num/2

return a-----------------------------函数代码后面的代码不会被运行

c=100

print c------------------------------无法执行

fun()

def fun1():

a=fun()-----------------------------函数传递的方法也就是上面的结果

a *=2

print a

fun1()

num =100

def fun():

a =num-50

print a-------------------------------------#50

fun()

print num------------------------------------#100

十、格式化字符串函数：

a=‘{} {}’.format(‘hello’,1)#--------一个括号对应一个实参，花括号里面有参数会显示索引对应的参数

（花括号里可通过索引，键取format里面值，如果为空则显示format后面与花括号相同的个数元素）

print a#--------------------------#hello 1

a=‘{1} {3}’.format(2,‘hello’,‘jdfa’,4)

print a----------------------------------------------------#hello 4

dic={‘name’:‘zhangsan’,‘age’:18}

c =‘{name} {age}’.format(**dic)-------c =‘{name} {age}’.format(name’=‘zhangsan’,‘age’=18)结果一样

print c----------------------------------------------------------#zhangsan 18

十一、内置函数open（）

1）read()一次性读取

注释无中文

o=open(“路径”,‘r’)--------------------------mode可以为’r’,‘w’,‘a’,可读可写，可追加

c=o.read()-----------------------------------读取文件内容

print c.----------------------------------------读取所有内容

c_path=

注释有中文路径

c_path='E:\untitled\lssos_\less\zuoye\哈哈

path=unicode(0,‘utf8’)----------------------------将c_path的中文路径进行字符集转码

o=open(“路径”,‘r’)

c=o.read()--------------------------------------------读取所有内容

（c=o.readline()）----------------------------------读取当前文件第一行

（c=o.readline()）----------------------------------读取当前文件路径中的所有内容

print c

2）write():“w”是覆盖插入

o=open(“C:\select.txt”,“w”)

o.write(“多测师”) ------------------#多测师-----用w写的模式文件中之前的内容会被全部覆盖替换掉

o.writelines(“\n多测师”) ----------#换行追加插入多测师-------------\n是换行

（o.close() #关闭文件）

write():“a是追加插入

o=open(“C:\select.txt”,“a”)

o.write(“123\n”)--------不加\n,默认后面直接追加内容—write/writelines()函数必须接字符串不能接整形

（o.writelines‘321’）

字典常见操作
1)字典的遍历：for…in…遍历字典
d_ict={‘name’:‘zhnagsan’,‘age’:18}--------------------------直接定义字典
print d_ict
a=[(‘name’,‘zhangsan’),(‘’,‘lisi’),(‘age’,18)]--------------转录定义字典–print type(a)—<type ‘list’>
print type(a)--------------------------------------------------------查看字符类型<type ‘list’>
d_ict=dict(a)
print d_ict-----------------------------------------------------------转录定义字典（通过dict()方法定义）
d={‘name’:‘zhang’,‘age’:18}
print d.values()-------------------------第一种方法只能打印值----#[18, ‘zhang’]
c=d.values()
print c------------------------------------第一种方法只能打印值----#[18, ‘zhang’]
c=d.values()-----------------------------print type(d.values())-----#<type ‘list’>
a={‘name’:‘zhang’,‘age’:18}