python基础---函数以及常用变量

函数及变量

函数

使用def关键字

在参数名前面的*表示args是一个可变参数

def add(*args):
    total = 0
    for val in args:
        total += val
    return total


# 在调用add函数时可以传入0个或多个参数
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 3, 5, 7, 9))

由于Python没有函数重载的概念，那么后面的定义会覆盖之前的定义，也就意味着两个函数同名函数实际上只有一个是存在的。

Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的foo函数

在引用的时候如果引用两个相同名字的函数, 后面的会覆盖前面的函数

• 在定义函数模块的时候使用"if __name__ == '__main__':"关键字会在只有运行着一个模块的时候运行这一个模块

def is_prime(num):
    """判断一个数是不是素数"""
    for factor in range(2, int(num ** 0.5) + 1):
        if num % factor == 0:
            return False
    return True if num != 1 else False

参数的作用域

def foo():
    b = 'hello'

    # Python中可以在函数内部再定义函数
    def bar():
        c = True
        print(a)
        print(b)
        print(c)

    bar()
    # print(c)  # NameError: name 'c' is not defined


if __name__ == '__main__':
    a = 100
    # print(b)  # NameError: name 'b' is not defined
    foo()

这时候三个参数都可以打印出来

a=>全局部变量

b=>函数中的局部变量, 但是对于其内部的函数来说, b属于嵌套作用域

c=>局部作用域

Python查找一个变量时会按照“局部作用域”、“嵌套作用域”、“全局作用域”和“内置作用域”的顺序进行搜索，前三者我们在上面的代码中已经看到了，所谓的“内置作用域”就是Python内置的那些标识符，我们之前用过的input、print、int等都属于内置作用域。

当函数中的参数和外部的全局变量同名的时候使用局部变量

def foo():
    a = 200			# 相当于一个新的变量
    print(a)  # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 100

在函数里面使用 全局变量 = value实际不是调用这一个全局变量, 是创建了一个新的一样名字的变量

想要这时候调用全局变量可以使用关键字global

def foo():
    global a
    a = 200
    print(a)  # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 200

如果全局里面没有a会在下一行定义全局的a变量

def foo():
 global a
 a = 200
 print(a)

if __name__ == "__main__":
 foo()
 print(a)

这个里面的第二个a可以正常打印

如果想要修改的是嵌套作用域里面的变量, 使用的是关键字nonlocal

• 建议在操作的时候把所有的变量都在函数里面实现

数据的传递

函数调用时的机制：有一实际参数a，在调用时产生一个新的变量x（形式参数），x和a指向相同的地址。如果对x赋值，意味着改变了x指向的内存块，而不改变a的值。如果x是列表，对x[0]赋值，则改变了x[0]指向的内存块，而又因为x[0]的地址是存放在列表中，a又指向了这个列表，因此a也被修改了。

Python函数中修改变量（值传递、引用传递、可变对象、不可变对象）的深入思考_python引用类型在函数内修改-CSDN博客

这一点是引用部分的知识

注意: 如果函数的缺省参数是一个列表, 没有指定的时候这一个列表会一直是同一个列表, 可以使用append之类的方法进行改变

返回值

使用return, 没有return的时候实际返回的是一个NULL

可以一次性返回多个数值

def func():
    return a, b, c
num1, num2, num3 = func()

这一个返回的是一个元组

可以在定义函数的时候使用->类型定义这一个函数的返回值

def __init__(self) -> None:
        pass

函数的文档

def func():
    """
    这是一个说明
    """
    pass

在交互模式里面可以使用help(print)这样的方式获取文档

重复定义

定义两个函数的名字一样的时候, 会执行后面的那一个

缺省参数

也叫默认参数, 在定义参数的时候使用=进行赋值, 这一个参数没有传入的时候会使用默认的那一个值

def func(value1, value2 = 2):
	pass

命名参数

在函数调用的时候可以指定这一个参数的名字, 直接把这一个值传递给这一个参数

def func(a, b, c):
    pass
func(b = 3, b = 1, a = 3)

没有命名的参数需要在左边

不定长参数

使用的时候有两种

• *args: 函数多余的参数会使用元组的形式在args里面, 这一个参数需要是未命名参数

def func_test(a, b, c, *args):
    print(a, b, c, args)

func_test(2, 1, 3, 3, 4, 5)

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
2 1 3 (3, 4, 5)

使用的时候如果希望参数传递的使用优先给不定长参数, 而不是给命名参数, 需要把*args这一个参数放在命名参数前面

• **kwargs: 多余的参数会使用键值对的形式存在这一个参数里面, 这一个参数需要是命名参数

def func_test(a, b, c, **kwargs):
    print(a, b, c, kwargs)

func_test(2, 1, 3, d = 3)

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
2 1 3 {'d': 3}

这两个参数在传递的时候可以使用*和**进行拆包, 达到按照原来的样子传递的方式

常用变量

字符串

定义

使用单引号或者双引号定义, 也可以使用三个引号定义有折行的字符串

s1 = 'hello, world!'
s2 = "hello, world!"
# 以三个双引号或单引号开头的字符串可以折行
s3 = """
hello, 
world!
"""
print(s1, s2, s3, end='')

hello, world! hello, world! 
hello,
world!

\后面还可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。也可以在\后面跟Unicode字符编码来表示字符，例如\u9a86\u660a代表的是中文“骆昊”。

• 如果不希望字符串中的\表示转义，我们可以通过在字符串的最前面加上字母r来加以说明

可以使用+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串（成员运算），我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符（切片运算）

切片

str2 = 'abc123456'
# 从字符串中取出指定位置的字符(下标运算)
print(str2[2]) # c
# 字符串切片(从指定的开始索引到指定的结束索引)
print(str2[2:5]) # c12
print(str2[2:]) # c123456
print(str2[2::2]) # c246
print(str2[::2]) # ac246
print(str2[::-1]) # 654321cba
print(str2[-3:-1]) # 45

[起始位置:结束位置:每一次的步长]

切片赋值

a = [11, 22, 33, 44]
a[1:3] = [1, 2, 3, 4, 5, 6]
print(a)

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
[11, 1, 2, 3, 4, 5, 6, 44]

会把这一个段进行替换

占位符

在Python中，print函数用于将内容输出到控制台。当使用print函数时，用{}来表示占位符，可以在字符串中插入变量的值。例如：

name = "Alice"
age = 30
print("My name is {} and I am {} years old.".format(name, age))

在上面的例子中，{}会被name和age的值替换，输出结果为"My name is Alice and I am 30 years old."

通过位置

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

通过关键字

print("网站名：{name}, 地址 {url}".format(name="jiao", url="http://www.xvsenfeng.asia/"))
 
# 通过字典设置参数
site = {"name": "jiao", "url": "http://www.xvsenfeng.asia/"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['jiao', 'http://www.xvsenfeng.asia/']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return 'name is {self.name}, age is {self.age}'.format(self = self)

通过映射

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

b_dict = {'name': "jiao", 'age': 21}
print('my name is {name}, age is {age}'.format(**b_dict))
print('my name is {info[name]}, age is {info[age]}'.format(info = b_dict))

在使使用一个字典的时候, 不能使用"key"的形式

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:-.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)	1011 11 13 b 0xb 0XB	进制

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

print ("{} 对应的位置是 {{0}}".format("runoob"))
runoob 对应的位置是 {0}

列表list

使用[], 用于存储多个数据

可以使用下标的方式进行访问, 也可以使用切片

使用len()可以获取这一个链表的长度

python里面的链表可以存储不同数据类型的数据

元组tuple

这一个和列表很像, 但是里面的数据不能进行修改, 使用()

这一个里面只有一个参数的时候, 需要加一个,

集合set

这一个里面不能有重复的数据, 使用{}

有重复的数据的时候会把里面的重复的数据只保存一次

这一个的顺序是随机的

字典dict

{key : value, key2 : value...}

这一个里面的key这一个不能重复

获取数据的时候需用使用key进行获取它对应的值

使用for对着一个进行遍历的时候, 实际获取到的时候这一个字典的key的信息(相当于dict.keys())

也可以对dict.values()进行遍历, 这一个可以直接获取这一个字典里面的value

也可以使用dict.items(), 可以获取这一个字典的元素, 使用一个元组返回一个键值对