Python 杂记

公用方法

  • 合并操作 +​

    • 两个对象相加操作，会合并两个对象
    • 适用于字符串，列表，元组
    • strA = '人生苦短'
strB = '我用Python'
print(strA + strB) # 人生苦短我用Python

listA = list(range(10))
listB = list(range(11, 20))
print(listA + listB) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

  • ​*​ 复制

    • 对象自身按指定次数进行 +​ 操作
    • 适用于字符串，列表，元组
    • strA = '人生苦短'
print(strA * 3) # 人生苦短人生苦短人生苦短

listA = list(range(10))
print(listA * 3) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  • ​in​ 判断元素是否存在

    • 判断指定元素是否存在于对象中
    • 适用于字符串，列表，元组，字典
    • strA = '人生苦短'
print('生' in strA) # True
print('我' in strA) # False

listA = list(range(10))
print(22 in listA) # False
print(9 in listA) # True

dictA = {'name': 'peter'}
print('age' in dictA) # False
print('name' in dictA) # True

缺省参数

  • 缺省参数，在调用函数时如果没有传参数，那么会使用定义函数时给的缺省值。
  • 缺省参数必须在参数列表的最后面，否则会报错。
def sum(a, b=40, c=90):
    print('默认参数使用=%d'%(a + b))
    pass

sum(10) # 50
sum(2, 56) # 58

可变参数

  • ​*​ 来定义
  • 在函数体内，可变参数是一个元组类型
def getComputer(*args):
    print(args)
    pass

getComputer() # ()

getComputer(1) # (1,)

getComputer(1, 2, 3, 4, 5, 6) # (1, 2, 3, 4, 5, 6)

getComputer((1, 2, 3), 4, 5, 6) # ((1, 2, 3), 4, 5, 6)

关键字可变参数

  • ​**​ 来定义
  • 在函数体内，参数关键字是一个字典类型，key 是一个字符串
def keyFunc(**kwargs):
    print(kwargs)
    pass

dict = {'name':'Leo', 'age':35}
keyFunc(**dict)

keyFunc(name='peter', age=26)

keyFunc() # {}

def complexFunc(*args, **kwargs):
    print(args)
    print(kwargs)
    pass

complexFunc() # () {}

complexFunc(1, 2, 3, 4) # (1, 2, 3, 4) {}

complexFunc(age=36) # () {'age': 36}

complexFunc(1, 2, 3, 4, name='刘德华') # (1, 2, 3, 4) {'name': '刘德华'}
  • 可选参数必须放到关键字可变参数之前
  • 可选参数：接受的数据是一个元组类型
  • 关键字可选参数：接受的数据是一个字典类型

函数返回值

  • 概念：函数执行完以后，会返回一个对象，如果在函数的内部有 return​ 关键字，就可以返回实际的值；否则返回的是 None​
  • 类型：可以返回任意类型，返回值类型取决于 return​ 后面的类型
  • 用途：给调用方返回数据
  • 在一个函数体内，可以出现多个 return​ 关键字，但是只能返回一个 retrun​
  • 如果在一个函数体内执行了 return​ ，就意味着函数执行完成退出了，return​ 后面的代码语句将不会执行
  • 返回多个值时，使用逗号隔开，函数会将多个返回值使用元组进行返回
def sum(a, b):
    sum = a + b
    return sum # 将计算的结果返回

print(sum(10, 20)) # 函数的返回值返回到调用的地方 # 30

rs = sum(10, 30) # 将返回值赋给其他的变量
print(rs) # 40

匿名方法

  • Python 中使用 lambda​ 关键字创建匿名函数，所谓匿名即这个函数没有名字，不用 def​ 关键字创建的函数。

  • 格式：

    lambda 参数1, 参数2, 参数3: 执行代码语句

  • 使用 lambda 表达式计算两个数的和：

    test = lambda x, y: x + y
test(1, 3)
test(4, 5)

  • 换成普通函数

    def test(x, y):
    return x + y

  • 匿名函数冒号后面的表达式有且只有一个，注意：是表达式，而不是语句

  • 匿名函数自带 return​ ，而这个 return​ 的结果就是表达式计算后的结果

lambda 与 三元运算

如下语句：

if a:
    b
else:
    c

能够由以下等效的表达式来模拟：

b if a else c

这样的表达式（三元运算）能够放在 lambda 中，它能够在 lambda 函数中来实现选择逻辑：

greater = (lambda x, y: x if x > y else y)

greater(3, 5)
greater(6, 2)

# 直接调用
print((lambda x, y: x if x > y else y)(3, 5))
print((lambda x, y: x if x > y else y)(6, 2))

lambda 表达式缺点：

  • lambda 只能是单个表达式，不是一个代码块，lambda 的设计就是为了满足简单函数的场景
  • 仅仅能封装有限的逻辑，复杂逻辑实现不了，必须使用 def​ 来处理

内置函数

内置函数——数学运算

常用的数学运算函数

方法 说明
​abs()​ 绝对值
​round()​ 取近似值
​pow()​ 求幂运算
​divmod()​ 求余和商
​max()​ 最大值
​min()​ 最小值
​sum()​ 求和
​eval()​ 动态执行表达式

abs() 求绝对值函数

  • 描述：abs()​​ 函数返回数字的绝对值
  • 语法：abs(x)​​
  • 参数：x —— 数值表达式
  • 返回值：函数返回 x （数字）的绝对值
abs(10) # 10
abs(-10) # 10
abs(-10.023) # 10.023

round() 取近似值

  • 描述：round()​​ 方法对浮点数进行近似取值，保留小数

  • 语法：round(x[, n])​​

  • 参数：

    • x —— 取近似值的值
    • n —— 保留几位小数

  • 返回值：返回浮点数 x 的近似值

round(2.6) # 3
round(2.4) # 2
round(2.5) # 2
round(2.55, 1) # 2.5
round(2.675, 2) # 2.67

注意：这里不完全是按照四舍五入或者四舍六入五成双来进行取值的，取值和 Python 的版本有关，还和浮点数的精度有关

pow() 求指数

  • 描述：pow()​​ 方法返回 \(x^y\)（x 的 y 次方）的值

  • 语法：pow(x, y[, z])​​

  • 参数：

    • x —— 数字
    • y —— 数字
    • z —— x 的 y 次方除以 z 的余数，不指定该参数则只求 x 的 y 次方

  • 返回值：返回 \(x^y\)（x 的 y 次方）的值

pow(2, 3) # 8
pow(2, 3, 2) # 0
pow(2, 3, 4) # 0
pow(2, 3, 5) # 3

divmod() 求商和余数

  • 语法：divmod(a, b)​​

  • 参数：

    • a —— 被除数
    • b —— 除数

  • 返回值：一个包含商和余数的元组(a // b, a % b)

divmod(7, 3) # (2, 1)
divmod(9, 3) # (3, 0)

max() 求最大值

  • 描述：max()​​ 方法返回给定参数的最大值，参数可以为序列
  • 语法：max(x, y, z, ...)​​
  • 返回值：返回给定参数的最大值
max(80, 100, 1000) # 1000
max(-20, -50, 1, 30) # 30
max(0, 100, -300) # 100

min() 求最小值

  • 描述：min()​ 方法返回给定参数的最小值，参数可以为序列
  • 语法：min(x, y, z, ...)​
  • 返回值：返回给定参数的最小值

sum() 求和

  • 描述：sum()​ 方法对序列进行求和运算

  • 语法：sum(iterable[, start])​

  • 参数：

    • iterable —— 可迭代对象，如：列表，元组，集合
    • start —— 指定相加的参数，如果没有设置这个值，默认为0

  • 返回值：返回计算结果

eval() 执行字符串表达式

  • 描述：eval()​ 函数用来执行一个字符串表达式，并返回表达式的值

  • 语法：eval(expression[, globals[, locals]])​

  • 参数：

    • expression —— 表达式
    • globals —— 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象
    • locals —— 变量作用域，局部命名空间，如果被提供，可以是任何映射对象

  • 返回值：返回表达式计算结果

内置函数——类型转换

方法 说明
​int()​ 转换为整型
​float()​ 转换为浮点型
​str()​ 转换为字符串型
​ord()​ 字符转换为整型（返回字符的ASCII码值）
​chr()​ 整型转换为字符（根据ASCII码返回字符）
​bool()​ 转换为布尔型
​bin()​ 转换为二进制
​hex()​ 转换为十六进制
​oct()​ 转换为八进制
​list()​ 元组转换为列表
​tuple()​ 列表转换为元组
​dict()​ 创建字典
​bytes()​ 转换为字节数组

序列操作函数

函数 说明
​all()​
​any()​
​sorted()​
​reverse()​ 反转
​range()​
​zip()​
​enumerate()​

内置函数——Set

‍

实例方法与属性

实例方法

  • 在类的内部，使用 def​ 关键字可以定义一个实例方法，与一般函数定义不同，类方法必须包含参数 self​ ，且为第一个参数（可以将 self​ 改为其他名字，但是这个位置必须被占用）。
  • 一个类里面可以有多个实例方法
  • 实例方法归类的实例所有
class Animal(object):
    def test(self):
        print('我是实例方法')

    def show(self):
        print('Animal.show()')

属性

  • 类里面定义的变量。定义在类里面，方法外面的属性称为类属性，定义在方法里面使用 self​ 引用的属性称为实例属性
class Animal(object):
    color = '白色' # 类属性

    def __init__(self):
        self.name = '旺财' # 实例属性
posted @ 2023-10-03 17:15  天空之城00  阅读(25)  评论(0)    收藏  举报