让你程序事半功倍的python便捷函数用法大全

迈不过友情╰ 2023-09-29 10:27 5阅读 0赞

**目录**

1.import time

2.import random

3. type(参数)函数：

4. print()函数:

5. round()函数：

6. input()函数：

7. append()函数:

8.len()函数:

9. 元组

10. pop()函数：

11. extend()函数：

12. Python的三种排序⽅式sort()函数

13. reverse()函数：

14.range()函数：

15. bool()函数：

16.连接语句and，or，not，in，not in

17. 代码规范：格式化字符串

18. format()函数

19. join()函数：

20. index()函数

21. try语法：

22. return语句

23. ⾃定义函数：

24. 读写⽂件格式规范：

25. readlines()函数：

26. writelines()函数：

27. split()函数：

28. join()函数：

29. dir()函数：

30. csv模块中常⽤的类⽅法

31. python技巧专栏

--------------------

> 查询英文取名【⽹址】 ：https://unbug.github.io/codel
> 
> 所有报错的查询【⽹址】：  https://www.runoob.com/python/python-xceptions.html

## 1.import time  ##

> **\#调⽤time模块**

>  *  time.sleep(n)\#n代表n秒，程序休眠n秒 
>  *  time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) 
>  *  time.localtime():读取当前时间 
>  *  time.strftime('格式',时间参数)：
>  *  格式为%Y-%m-%d %H:%M:%S ，参数为当前时间2022-04-15 21:36:45

## 2.import random  ##

> **\#调⽤random随机数模块**

>  **randint()函数：** 
> 
>  *  格式：random.randint(a,b)

> 代码范例：

X = random.randint(a,b) #从a到b产⽣⼀个随机整数并赋值给X
    list1 = [1,2,3,4,5,6,]

>  **random.sample(seq, n)** 
> 
>  *  \#写法是random.sample() 
>  *  \#需要传递两个参数，第⼀个参数是⼀个序列（列表、字符串、元组），第⼆个参数是随机选取的元素个数 
>  *  list2 = random.sample(list1,3)\#把list1中的随机3个元素拿出来组成list2

> 随机选择函数 
> 
> 格式：random.choice(参数,个数)

> 范例代码：

dict1 = {['A':[],'B':[],'C':[]}
    dict2 = random.choice(dict1,2)#从dict1中随机选2个组成dict2

## 3. type(参数)函数： ##

>  **查询参数的类型**

>  **强制转换函数：str()\\int()\\float() + 将内容拼接，需要统⼀类型为str()** 
> 
>  *  str()函数 
>  *  int()函数 
>  *  float()函数 
>  *  格式：str(参数)/int(参数)/flfloat(参数)

> 范例代码：

print(int(float('1.5')))#str型先转为float型，再转成int型

> 注意：int()只能转换纯整数字符串类浮点数字符串如'1.5'中的⼩数点是⽆法被int函数直接识别转换的，会报错

## 4. print()函数: ##

>  *  格式：print('',end='') 
>  *  end参数可省略不写，默认 end = '\\n' 
>  *  print函数⼀种⽤法，⽤逗号隔开，可在同⼀⾏打印不同类型的数据。 
>  *  print(x,'/',y,'=',z)

> 范例代码：

i = 2
    j = 4
    print('%d * %d = %-2d' % (i,j,i*j),end = 'A')

## 5. round()函数：  ##

> 格式：round(参数，数位)函数 
> 
> 代码范例：

print(round((0.55+0.3),2)))

## 6. input()函数：  ##

>  *  格式：input('字符串') 
>  *  返回值：在屏幕上显示'字符串'，并存储⽤户输⼊的数据(str型)

> 代码范例：

A = input('请输⼊')#假设⽤户输⼊了1+1
    print (A) # A == '1+1'
    >>>请输⼊
    >>>1+1

## 7. append()函数: ##

>  *  列表操作：在列表末尾添加新元素 
>  *  格式：列表名.append(新元素)\#举例：list1.append(n) 
>  *  新元素只能是⼀个，可以是任意类型，甚⾄是⼀个列表

> 范例代码：

list3 = [1,2]
    list3.append(3)#添加单个元素 3 在列表list3末尾
    print(list3)#输出 [1,2,3]
    list3.append(4,5)#不可添加多个元素，会报错

> \#**报错信息：list3.append(4,5)** 
> 
> TypeError: append() takes exactly one argument (2 given) list3.append(\[4,5\])\#添加⼀个新的列表在末尾

print(list3)#输出 [1,2,3[4,5]]

## 8.len()函数: ##

>  *  列表/字典操作：求列表/字典⻓度并返回⼀个⻓度值 
>  *  格式：len(列表/字典名)

> 范例代码：

scores = {'⼩明':95,'⼩红':90,'⼩刚':90}
    print(len(scores))

## 9. 元组 ##

>  *  tuple1 = ('A','B') 
>  *  元组名 赋值号 ⼩括号左 元素N个⽤逗号隔开 ⼩括号右 
>  *  和列表特别类似。

## 10. pop()函数： ##

>  *  功能：同时提取和删除某个元素(抓出来某元素)，默认最后⼀个 
>  *  格式：列表.pop(下标)

> 范例代码：

students = ['⼩明','⼩红','⼩刚']
    student1 = students.pop(0)
    print(students) #输出['⼩红','⼩刚']
    print(student1) #输出： ⼩明

## 11. extend()函数：  ##

>  *  格式：列表.extend(列表2)

> 范例代码：

list1 = [91, 95, 97, 99]
    list2 = [92, 93, 96, 98]
    list1.extend(list2)
    print(list1)

## 12. Python的三种排序⽅式sort()函数  ##

>  *  格式1：列表.sort()升序排序 
>  *  格式2：列表.sort(reverse=True)降序排序 
>  *  格式3：列表.reverse反转排序

> 范例代码：

list1 = [91, 95, 97, 99, 92, 93, 96, 98]
    list1.sort()
    print(list1)
    #[91, 92, 93, 95, 96, 97, 98, 99]
    list1.sort(reverse=True)
    print(list1)
    #[99, 98, 97, 96, 95, 93, 92, 91]

## 13. reverse()函数： ##

list1 = [91, 95, 97, 99, 92, 93, 96, 98]
    list1.reverse()
    print (list1)
    #[98, 96, 93, 92, 99, 97, 95, 91]

## 14.range()函数： ##

>  *  格式：range(a,b,c)，\#从a数到b-1,数的间隔为c 
>  *  当默认 a=0 时可省略为range(b),注意c也不能写 
>  *  当默认 c=1 时可省略为range(a,b) 
>  *  通常与for循环配合使⽤ 
>  *  作⽤相当于⽣成⼀个⻓度为b-a的序列list1 = \[a,a+1,a+2......b-1\]

> 范例代码：

for i in range(0,10,3):
    print(i)

## 15. bool()函数：  ##

>  *  格式：bool(参数)

> 代码范例：

print('以下数据判断结果都是【假】：')print(bool(False))
    print(bool(0))
    print(bool(''))
    print(bool(None))
    print('以下数据判断结果都是【真】：')
    print(bool(True))

## 16.连接语句and，or，not，in，not in ##

>  *  格式：语句1 and 语句2 
>  *  **返回值：** 
> 
> 1.  0 and 0 == 0 
> 2.  0 and 1 == 0 
> 3.  1 and 0 == 0 
> 4.  1 and 1 == 1

>  *  not 语句 
>  *  格式： not 语句 
>  *  **返回值：** 
> 
> 1.  not 0 == 1 
> 2.  not 1 == 0

>  *  in 语句 / not in 语句 
>  *  格式： 参数 (not) in 语句

> **代码范例：** 
> 
> a = \[0,1\] 
> 
> >>> 0 in a 
> 
> True
> 
> >>> 1 not in a 
> 
> False

## 17. 代码规范：格式化字符串  ##

>  *  格式：'%s %d %f'% ('字符串'，整型参数，浮点型参数) 
>  *  注意和字典类似，⽆序，位置、类型唯⼀对应

> 范例代码：

lucky = 8
    print('我的幸运数字是%d' % lucky)
    #我的幸运数字是8
    print('我的幸运数字是%d' % 8)
    #我的幸运数字是8
    print('我的幸运数字是%s' % '⼩⻰⼥的⽣⽇816')
    #我的幸运数字是⼩⻰⼥的⽣⽇816
    print('我的幸运数字是%d和%d' % (8,16))
    #我的幸运数字是8和16

## 18. format()函数  ##

>  *  格式：'...\{\}...\{\}...'.format(元素1，元素2......)

> 范例代码：

print('\n{}{}'.format('数字：',0)) #优势1：不⽤担⼼⽤错类型码。
    print('{}，{}'.format(0,1)) #不设置指定位置时，默认按顺序对应。
    print('{1}，{0}'.format(0,1)) #优势2：当设置指定位置时，按指定的对应。
    print('{0}，{1}，{0}'.format(0,1)) #优势3：可多次调⽤format后的数据。
    name2 = 'Python基础语法'
    print('我正在学{}'.format(name2)) # format()函数也接受通过参数传⼊数据。

## 19. join()函数： ##

>  *  语法： 'sep'.join(seq) 
>  *  参数说明：
> 
> 1.  sep：分隔符。可以为空 
> 2.  seq：要连接的元素序列、字符串、元组、字典 
> 
>  *  上⾯的语法即：以sep作为分隔符，将seq所有的元素合并成⼀个新的字符串 
>  *  \#列表、元组可得到相同结果(可理解为去掉括号，⽤分隔符分隔每个元素) 
>  *  \#字典操作后得到的是 键(舍弃值) 
>  *  \#字符串操作后得到的是每个单字符 
>  *  返回值：返回⼀个以分隔符sep连接各个元素后⽣成的字符串

> 范例代码：

> **\#对序列进⾏操作（分别使⽤' '与':'作为分隔符）** 
> 
> >>> seq1 = \['hello','good','boy','doiido'\] 
> 
> >>> print ' '.join(seq1) 
> 
> hello good boy doiido 
> 
> >>> print ':'.join(seq1) 
> 
> hello:good:boy:doiido

> **\#对字符串进⾏操作** 
> 
> >>> seq2 = "hello good boy doiido" 
> 
> >>> print ':'.join(seq2) 
> 
> h:e:l:l:o: :g:o:o:d: :b:o:y: :d:o:i:i:d:o

> **\#对元组进⾏操作** 
> 
> >>> seq3 = ('hello','good','boy','doiido') 
> 
> >>> print ':'.join(seq3) 
> 
> hello:good:boy:doiido

> **\#对字典进⾏操作** 
> 
> >>> seq4 = \{'hello':1,'good':2,'boy':3,'doiido':4\} 
> 
> >>> print ':'.join(seq4) 
> 
> boy:good:doiido:hello

## 20. index()函数  ##

>  *  格式：list.index(obj)，obj为object（对象）的缩写 
>  *  描述：index() 函数⽤于找出列表中某个元素第⼀次出现的索引位置 
>  *  具体可参考代码和运⾏结果。

> 范例代码：

num = [0,1,0,1,2]
    print(num.index(1)) # 数字1⾸先出现的索引位置是list[1]（索引位置从0开始）。
    print(num.index(2)) # 数字2⾸先出现的索引位置是list[4]。

## 21. try语法：  ##

>  *  try:执⾏命令(⼤部分情况是⽤户输⼊) 
>  *  except 报错类型1: 
>  *  except 报错类型2: 
>  *  报错类型有： 
> 
> 1.  精确报错：ZeroDivisionError、ValueError、TypeError、 
> 2.  精确报错(多项)：(报错类型1,报错类型2...) 
> 3.  模糊报错：Exception

> 范例代码1：

num = [1,2,0,3,1.5,'6']
    for x in num:
    try: # 尝试执⾏下列代码
    print (6/x)
    except ZeroDivisionError:
    print('0是不能做除数的！')
    except TypeError:
    # 当报错信息为TypeError，执⾏下⾯的语句。
    print('被除数必须是整值或浮点数！')

> 范例代码2：

print('\n欢迎使⽤除法计算器！\n')
    while True:
    try:
    x = input('请你输⼊被除数：')
    y = input('请你输⼊除数：')
    z = flfloat(x)/flfloat(y)
    print(x,'/',y,'=',z)
    break # 默认每次只计算⼀次，所以在这⾥写了 break。
    except ZeroDivisionError: # 当除数为0时，跳出提示，重新输⼊。
    print('0是不能做除数的！')except ValueError: # 当除数或被除数中有⼀个⽆法转换成浮点数时，跳出提示，重新输⼊。
    print('除数和被除数都应该是整值或浮点数！')
    # ⽅式2：将两个（或多个）异常放在⼀起，只要触发其中⼀个，就执⾏所包含的代码。
    # except(ZeroDivisionError,ValueError):
    # print('你的输⼊有误，请重新输⼊！')
    # ⽅式3：常规错误的基类，假设不想提供很精细的提示，可以⽤这个语句响应常规错误。
    # except Exception:
    # print('你的输⼊有误，请重新输⼊！')

## 22. return语句  ##

>  return语句就是将结果返回到调⽤的地⽅，并把程序的控制权⼀起返回，程序运⾏到所遇到的第⼀个return即返回（退出def块），不会再运⾏第⼆个return。要返回两个数值，写成⼀⾏即可：

> 范例代码：

def a(x,y):
        if x==y:
            return x,y
        print a(3,3)<br><br>>>> 3,3
        return a,b # return 多个值时，返回⼀个元组(a,b)

> **但并不意味着⼀个函数体中只能有⼀个return 语句，例如：**

def test_return(x):
        if x > 0:
            return x
        else:
            return 0
    #函数没有 return，默认 return⼀个 None 对象。

> **递归函数中没有return 的情况：**

def gcd(a,b):
        if a%b==0:
            return b
        else:
            gcd(b,a%b)

> 分析：else 中没有 return 就没有出⼝，这个程序是⾃⼰内部运⾏，程序没有返回值，

> **return 和 print 的区别：** 
> 
> 在交互模式下，return的结果会⾃动打印出来，⽽作为脚本单独运⾏时则需要print函数才能显 示。

x = 1
    y = 2
    def add (x, y):
        z = x + y
        return z
    print (add(x,y)

> **默认情况下，遇⻅ return 函数就会返回给调⽤者，但是 try，fifinally情况除外：**

def func():
        try:
            print(98)
            return 'ok' #函数得到了⼀个返回值
        fifinally: #fifinally语句块中的语句依然会执⾏
            print (98)
            print fun()

> 输出： 
> 
> >>>98 
> 
> >>>98 
> 
> >>>ok

> **函数作为返回值返回:**

def lazy_sum(*args):
        def sum():
            x=0
            for n in args:
                x=x+n
            return x
        return sum
    lazy_sum(1,2,3,4,5,6,7,8,9)
    #这时候lazy_sum 并没有执⾏，⽽是返回⼀个指向求和的函数的
    函数名sum 的内存地址。
    f=lazy_sum(1,2,3,4,5,6,7,8,9)
    print(type(f))
    print(f()) # 调⽤f()函数，才真正调⽤了 sum 函数进⾏求和，这其实就是闭包。

> 返回⼀个函数列表：

def f():
        return i*i
    def count():
        fs = []
        for i in range(1,4):
            fs.append(f)
        return fs
    f1, f2, f3 = count()
    print(f1())
    print(f2())
    print(f3())

> 输出：
> 
> >>>9 
> 
> >>>9 
> 
> >>>9

> 执⾏过程： 
> 
>  *  当i=1, 执⾏for循环， 结果返回函数f的函数地址，存在列表fs中的第⼀个位置上。 
>  *  当i=2, 由于fs列表中第⼀个元素所指的函数中的i是count函数的局部变量，i也指向了2；然后执⾏for循环， 结果返回函数f的函数地址，存在列表fs中的第⼆个位置上。 
>  *  当i=3, 同理，在fs列表第⼀个和第⼆个元素所指的函数中的i变量指向了3； 然后执⾏for循环， 结果返回函数f的函数地址，存在列表fs中的第三个位置上。 所以在调⽤f1()的时候,函数中的i是指向3的：

> 闭包时牢记的⼀点就是：返回函数不要引⽤任何循环变量，或者后续会发⽣变化的变量。即包在⾥⾯的函数（本例为f()），不要引⽤外部函数(本例为count())的任何循环变量， 如果⼀定要引⼊循环变量，⽅法是再创建⼀个函数，⽤该函数的参数绑定循环变量当前的值，⽆论该循环变量后续如何更改，已绑定到函数参数的值不变：

> **返回值条件判断句式：** 
> 
> return a if 条件A成⽴ (else 条件B)

## 23. ⾃定义函数：  ##

> **def 函数名**(参数1(位置参数),\*参数2(不定⻓参数),参数3=默认值(默认参数)):\#可以没有参数， 
> 
> 这样只有⼀种输出。 
> 
> (缩进空格)函数主体内容\#如对参数进⾏何种改变 
> 
> (缩进空格)return语句\#可以没有return语句，和return None同样效果，return a if A else B

> 范例代码：

def menu(appetizer,course,*barbeque,dessert='绿⾖沙'):
        print('⼀份开胃菜：'+appetizer)
        print('⼀份主菜：'+course)
        print('⼀份甜品：'+dessert)
    for i in barbeque:
        print('⼀份烤串：'+i)
        menu('话梅花⽣','⽜⾁拉⾯','烤鸡翅','烤茄⼦','烤⽟⽶',dessert = '银⽿羹')

> **class 类A():**

变量1 = 100
    @classmethod
    def 函数A(cls):
            print(cls.变量1)

>  *  第⼀个格式@classmethod的中⽂意思就是“类⽅法”，@classmethod声明了函数1是类⽅ 法，这样才能允许函数1使⽤类属性中的数据。 
>  *  第⼆个格式cls的意思是class的缩写。如果类⽅法函数1想使⽤类属性（也就是类中的变 量），就要写上cls为函数1的第⼀个参数，也就是把这个类作为参数传给⾃⼰，这样就能被允许使⽤类中的数据。 
>  *  第三个格式是cls.变量。类⽅法想使⽤类属性的时候，需要在这些变量名称前加上cls.。

## 24. 读写⽂件格式规范：  ##

> 第⼀种：普通写法

#打开⽂件
    fifile1 = open('路径','只读r/重写w/追加a'，encodeing = 'utf-8 or gbk')#路径含 \ ，⽤\\代
    替或在路径前加r
    #读取⽂件
    fifilecontent = fifile1.read()
    #写⼊⽂件
    fifile1.write('写⼊的内容')
    #打印⽂件
    print(fifilecontent)
    #关闭⽂件
    fifile1.close()

> 第⼆种：with关键字写法

with open ('路径','只读r/重写w/追加a') as fifile1:
    #with open('⽂件地址','读写模式') as 变量名:(冒号不能丢)
    fifile1.write('写⼊内容')
    #缩进，⽆需close()函数

## 25. readlines()函数：  ##

>  *  功能：“按⾏读取”
>  *  格式：变量名 = ⽂件名.readlines()

> 范例代码：

fifile1 = open('/Users/Ted/Desktop/scores.txt','r',encoding='utf-8')
    fifile_lines = fifile1.readlines()
    fifile1.close()
    print(fifile_lines)readlines() 会从txt⽂件取得⼀个列表，列表中的每个字符串就是scores.txt中的每⼀⾏。⽽且每个字符串后⾯还有换⾏的\n符号

## 26. writelines()函数： ##

>  *  功能：“按⾏重写” 
>  *  格式：⽂件名.writelines(参数)

> 范例代码：

fifinal_scores = [1,3,5,76,7,8]
    winner_new = open('winner_new.txt','w',encoding='utf-8')
    winner_new.writelines(fifinal_scores)
    winner_new.close()

## 27. split()函数：  ##

>  *  格式：参数.split()\#不带参数形式，默认空格替换成分隔符，不管空格在哪，或者有⼏个 全部被镐掉,得到⼀个列表

> 范例代码：

st0 = ' song huan gong '
    print(st0.split())
    #['song', 'huan', 'gong']

> 格式2：参数.split('分隔符','分隔次数')，默认分隔次数最⼤值(字符串⻓度)

> 范例代码：

st0 = 'iisongiiihuaniiiigongi'
    print(st0.split('i'))
    #['', '', 'song', '', '', 'huan', '', '', '', 'gong', '']

## 28. join()函数：  ##

>  *  格式：参数1.join(参数2)\#⽤参数1将参数2串起来成为新的字符串

> 范例代码：

a = 'cat'
    b = '-'
    print(b.join(a))
    #c-a-t

## 29. dir()函数： ##

>  *  格式：dir(模块名/函数名/类型名) \#简单查看：

> 范例代码：

import csvfor i in dir(csv):
        print(i)

## 30. csv模块中常⽤的类⽅法  ##

>  *  csv.reader(csvfifile,dialect = 'excel',\*\*fmtparams)\#fmpt参数

> 范例代码：

import csv
    with open('test.csv',newline='',encoding='utf-8')as f:
    data1 = csv.reader(f)#数据存在内存中，需要保持读取⽂件的姿势进⾏遍历操作
    for i in data1:#此处如果不缩进会报错，原因⻅上⼀条注释
        print(i)

import csv
    
    with open('test.csv','a',newline='',encoding='utf-8')as f:
    writer = csv.writer(f)
    writer.writerows(写⼊的内容)
    #注意：默认编码是Unicode，Python中默认编码utf-8，需指定。

> 范例代码：

import csv
    with open('test.csv','a', newline='',encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerow(['4', '猫砂', '25', '1022', '886'])
    writer.writerow(['5', '猫罐头', '18', '2234', '3121'])

> 引⽤模块语句直接写同⼀⾏中： 
> 
> print(''.join(\_\_import\_\_('random').choice('/\\\\') for i in range(50\*24)))

> **\# 知识1：⼀种新的列表⽣成⽅式** 
> 
> num1 = \[1,2,3,4,5\] \# 想⼀想，如果⽤这个⽅法⽣成⼀个1-100的列表…… 
> 
> num2 = list(range(1,6)) 
> 
> print(num1) 
> 
> print(num2)

> **\# 知识2：extend 的新⽤法** 
> 
> num2.extend(\['ABCDE'\]) 
> 
> num2.extend('ABCDE') \# extend后⾯是列表的话会将其合并，后⾯是字符串的话会将每个 字符当成⼀个列表中的元素。 
> 
> print(num2)

> **\# 知识点3：列表⽣成式** 
> 
> list1 = \[i for i in range(3)\] \# 规定列表中元素的范围 
> 
> print(list1) 
> 
> list2 = \[m+n for m in \['天字', '地字'\] for n in '⼀⼆'\] \# 列表元素可以是组合，分别规定范围。
> 
> print(list2) 
> 
> list3 = \[n\*n for n in range(1,11) if n % 3 == 0\] \# 元素既可规定范围，也可附加条件。 
> 
> print(list3)

--------------------

## 31. python技巧专栏 ##

[https://blog.csdn.net/weixin\_53919192/category\_11732953.html?spm=1001.2014.3001.5482![icon-default.png_t_M4AD][]https://blog.csdn.net/weixin\_53919192/category\_11732953.html?spm=1001.2014.3001.5482][https_blog.csdn.net_weixin_53919192_category_11732953.html_spm_1001.2014.3001.5482_icon-default.png_t_M4AD_https_blog.csdn.net_weixin_53919192_category_11732953.html_spm_1001.2014.3001.5482]

[icon-default.png_t_M4AD]: https://csdnimg.cn/release/blog_editor_html/release2.1.3/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=M4AD
[https_blog.csdn.net_weixin_53919192_category_11732953.html_spm_1001.2014.3001.5482_icon-default.png_t_M4AD_https_blog.csdn.net_weixin_53919192_category_11732953.html_spm_1001.2014.3001.5482]: https://blog.csdn.net/weixin_53919192/category_11732953.html?spm=1001.2014.3001.5482