Python基础语法

Posted 2023-02-16 小赵小赵福星高照～

Python基础语法(三)

文章目录

• Python基础语法(三)
• • 函数
  • • 函数是什么
    • 语法格式
    • 函数参数
    • 函数返回值
    • 变量作用域
    • 函数执行过程
    • 链式调用
    • 嵌套调用
    • 函数递归
    • 参数默认值
    • 关键字参数
  • 列表和元组
  • • 什么是列表，什么是元组
    • 创建列表
    • 访问下标
    • 切片操作
    • 遍历列表元素
    • 新增元素
    • 查找元素
    • 删除元素
    • 连接列表
    • 关于元组
  • 字典
  • • 字典是什么
    • 创建字典
    • 查找key
    • 新增/修改元素
    • 删除元素
    • 遍历字典元素
    • 取出所有key和value
    • 合法的key类型
  • 文件
  • • 文件是什么
    • 文件操作
    • • 1. 打开文件
      • 2. 关闭文件
      • 3. 写文件
      • 4. 读文件
    • 上下文管理器
  • 库
  • • 标准库
    • • 认识标准库
    • 第三方库
    • • 认识第三方库
      • 使用pip
    • 生成二维码
    • 实现文件查找工具

函数

函数是什么

数学当中的函数：三角函数：sin，cos，y=ax+b，一个x对应一个y，具有某种映射关系

而编程当中的函数是一段可以被重复使用的代码

# 1.求1-100的和
theSum = 0
for i in range(1, 101):
	theSum += i
print(theSum)

# 2.求300-400 的和
theSum = 0
for i in range(300,401):
	theSum += i
print(theSum)

# 3.求1-1000的和
theSum = 0
for i in range(1, 1001):
	theSum += i
print(theSum)

上面代码我们求了1-100的和，300-400的和，1-1000的和，我们发现功能都是类似的，我们可以使用函数来更加简洁的解决：

# 定义一个求和函数
def calcSum(begin,end):
    theSum = 0
    for i in range(begin,end):
        theSum += i
    print(theSum)

# 调用函数
# 1.求1-100的和
calcSum(1,101)
# 1.求300-400的和
calcSum(300,401)
# 1.求1-1000的和
calcSum(1,1001)

def为定义函数关键字。

语法格式

创建函数/定义函数：

def 函数名(形参列表):
    函数体
    return 返回值

形参列表中，可以有多个形参，多个形参之间使用逗号分隔，return语句并不是必须的。

调用函数/使用函数：

函数名(实参列表)	//不考虑返回值
返回值 = 函数名(实参列表)	//考虑返回值

• 函数定义并不会执行函数体内容，必须要调用才会执行，调用几次就会执行几次

• 定义在前，调用在后

函数参数

# 定义一个求和函数
def calcSum(begin,end):
    theSum = 0
    for i in range(begin,end):
        theSum += i
    print(theSum)

# 调用函数
# 1.求1-100的和
calcSum(1,101)
# 1.求300-400的和
calcSum(300,401)
# 1.求1-1000的和
calcSum(1,1001)

上面代码中：1，101，300，401，1，1001都是函数的实参，begin和end是函数的形参。

注意：

• 一个函数可以有一个形参，也可以有多个形参，也可以没有形参。
• 一个函数的形参有几个，那么传递实参的时候也得传几个，保证个数要匹配函数返回值

函数返回值

函数的参数可以视为是函数的“输入",则函数的返回值就可以视为是函数的“输出”。
此处的“输入",“输出”是更广义的输入输出,不是单纯指通过控制台输入输出.
我们可以把函数想象成一个"厂"，工厂需要买入原材料,进行加工,并生产出产品.
函数的参数就是原材料,函数的返回值就是生产出的产品
下列代码：

def calcsum(beg， end):
    sum=0
    for i in range(beg, end + 1):
    	sum += i
    print(sum)
calc(1,100)

可以转换成：

def calcsum(beg， end):
    sum=0
    for i in range(beg, end + 1):
    	sum += i
    return sum

result = calcSum(1, 100)
print(result)

这两个代码的区别就在于,前者直接在函数内部进行了打印,后者则使用return语句把结果返回给函数调用者,再由调用者负责打印.

我们一般倾向于第二种写法。
实际开发中我们的一个通常的编程原则,是“逻辑和用户交互分离"，而第一种写法的函数中, 既包含了计算逻辑，又包含了和用户交互(打印到控制台上)，这种写法是不太好的,如果后续我们需要的是把计算结果保存到文件中,或者通过网络发送或者展示到图形化界面里,那么第一种写法的函数, 就难以胜任了。

而第二种写法则专注于做计算逻辑,不负责和用户交互.那么就很容易把这个逻辑搭配不同的用户交互代码,来实现不同的效果。

Python中的一个函数可以返回多个值，C++要想返回多个值，可以通过输出型参数(指针/引用)

写一个函数，返回平面上的一个点：

def getPoint():
    x = 10
    y = 20
    return x, y


a, b = getPoint()
print(f"a = a,b = b")

虽然现在返回了多个值，但是只想用其中的一部分，不关注其他的，可以使用_来进行占位！

_, b = getPoint()

不要x，只要y，把y赋值给b即可！

变量作用域

观察以下代码

def getPoint():
    x = 10
    y = 20
    return x,y


x，y = getPoint()

在这个代码中,函数内部存在x, y,函数外部也有x，y。但是这两组x, y不是相同的变量，而只是恰好有一样的名字，变量只能在所在的函数内部生效。在函数getPoint()内部定义的x, y只是在函数内部生效，一旦出了函数的范围，这两个变量就不再生效了。

def getPoint():
    x=10
    y=20
    return x,y


getPoint()
print(x, y)

在不同的作用域中,允许存在同名的变量，虽然名字相同,实际上是不同的变量。

x=20
def test():
    x = 10
    print(f'函数内部x = x')
    

test()
print(f'函数外部x = x')

值为20的为全局变量，是在整个程序中都有效的，值为10的为局部变量，只是在函数内部有效

在函数里尝试读取全局变量，是可以的！当函数中尝试访问某个变量的时候，会先尝试在局部变量中查找，如果找到，就直接访问，如果没找到，就会往上一级作用域中进行查找。

如果想在函数里面修改全局变量：

x = 10
def test():
    # 声明x为全局变量,没有glabal，则会将x当成局部变量进行定义
    global x
    x = 20
    

test()
print(f"x = x")

像if，while，for这些语句的代码块当中定义的变量，在python当中是可以在外面进行访问的，而C++是不允许的。C++当中是有作用域的限制的，而Python当中的作用域的限制是函数以及类当中。

函数执行过程

• 调用函数才会执行函数体代码，不调用则不会执行
• 函数体执行结束(或者遇到return语句)，则回到函数调用位置继续往下执行。

链式调用

前面的代码很多都是写作

#判定是否是奇数
def isOdd(num) ;
	if num % 2 == 0:
		return False
	else:
		return True

result = isOdd(10)
print(result)

实际上也可以简化写作：

print(isOdd(10))

把一个函数的返回值，作为另一个函数的参数, 这种操作称为链式调用，这是一 种比较常见的写法。

嵌套调用

函数内部还可以调用其他的函数，这个动作称为“嵌套调用" .

def test():
    print ("执行函数内部代码")
    print ("执行函数内部代码")
    print ("执行团数内部代码")

test函数内部调用了print 函数这里就属于嵌套调用。
一个函数里面可以嵌套调用任意多个函数，函数嵌套的过程是非常灵活的。

函数递归

在Python中，我们知道一个函数可以调用其他函数。函数甚至可能会调用自身。这些类型的构造称为递归函数。

递归函数的示例，求一个数字的阶乘：

def calc_factorial(x):
    """这是一个
    求整数阶乘的递归函数"""
    if x == 1:
        return 1
    else:
        return (x * calc_factorial(x-1))
    

calc_factorial(4)

calc_factorial()是一个递归函数，它调用了自己。当我们用正整数调用此函数时，它将通过减少数量来递归调用自身。

每个函数将数字乘以该数字下面的数字的阶乘，直到它等于1。即4! = 4 * 3!，3! = 3 * 2!

递归调用的步骤：

calc_factorial(4)              # 1st call with 4
4 * calc_factorial(3)          # 2nd call with 3
4 * 3 * calc_factorial(2)      # 3rd call with 2
4 * 3 * 2 * calc_factorial(1)  # 4th call with 1
4 * 3 * 2 * 1                  # return from 4th call as number=1
4 * 3 * 2                      # return from 3rd call
4 * 6                          # return from 2nd call
24                             # return from 1st call

当数字减少到1时，递归结束。这称为基本条件。

每个递归函数必须具有停止递归的基本条件，否则该函数将无限调用自身。

Python解释器限制了递归的深度，以帮助避免无限递归，从而导致堆栈溢出。

默认情况下，最大递归深度为 1000。如果超出限制，则结果为RecursionError。

参数默认值

Python中的函数,可以给形参指定默认值.
带有默认值的参数可以在调用的时候不传参.
代码示例:计算两个数字的和

def add(x, y, debug=False):
	if debug:
		print(f"调试信息: x=x, y=y')
	return x+ y
              
print(add(10,20))
print(add(10, 20，True))

此处debug=False即为参数默认值，当我们不指定第三个参数的时候默认debug的取值即为False.

带有默认值的参数需要放到没有默认值的参数的后面

def add(x, debug=False, y):
	if debug: 
		print(f'调试信息: x=x, y=y')
	return x + y

print(add(10, 20))

关键字参数

在调用函数的时候,需要给函数指定实参，一般默认情况下是按照形参的顺序,来依次传递实参的。
但是我们也可以通过关键字参数，来调整这里的传参顺序,显式指定当前实参传递给哪个形参：

def test(x, y):
    print(f'x = x')
    print(f'y = y')
    
test(x=10, y=20)
test(y=100, x=200)

形如上述test(x=10, y=20)这样的操作,即为关键字参数。按照形参的名字进行传参，非常明显的告诉程序员，你的参数要传给谁！，可以无视形参和实参的顺序。

列表和元组

什么是列表，什么是元组

编程中,经常需要使用变量,来保存/表示数据。

如果代码中需要表示的数据个数比较少,我们直接创建多个变呈即可。

num1 = 10
num2 = 20
num3 = 30

但是有的时候,代码中需要表示的数据特别多,甚至也不知道要表示多少个数据，这个时候,就需要用到列表。列表是一种让程序猿在代码中批量表示/保存数据的方式
就像我们去超市买辣条,如果就只是买—两根辣条,那咱们直接拿着辣条就走了，但是如果一次买个十根八根的,这个时候用手拿就不好拿,超市老板就会给我们个袋子。这个袋子,就相当于列表。
元组和列表相比,是非常相似的,只是列表中放哪些元索可以修改调整,元组中放的元素是创建元组的时候就设定好的,不能修改调整。

列表和元组类似于C++当中的数组。列表可变，元组不可变。

创建列表

创建列表有两种方式：

1. 直接使用字面值来创建

a = []
# []表示一个空的列表

2. 使用list()来创建

b = list()

3. 可以在创建列表的时候，在[]中指定列表的初始值，元素之间使用,分割

a = [1, 2, 3, 4]
print(a)

C++当中要求一个数组里只能存相同类型的变量

4. 可以在同一个列表里放不同类型的变量

a = [1,'hello',True,1.0]
print(a)

访问下标

列表里面可以管理很多元素，通过下标访问的方式来访问列表中的元素，下标访问运算符：[]

a = [1,'hello',True,1.0]
print(a[0],a[1],a[2],a[3])

注意下标从0开始计数。

使用下标修改列表元素：

a = [1,'hello',True,1.0]
a[0] = 100
print(a)

下标的有效范围：[0,长度-1]，超出下标有效范围就是越界访问

可以使用内建函数len来获取到列表的长度，和字符串类似，len可以传参字符串，列表，元组，字典，自定义的类等，python中的下标，还可以写成负数，比如a[-1]表示列表a的倒数第一个元素，a[-2]表示列表a的倒数第二个元素

切片操作

通过下标操作是一次取出里面第一个元素，通过切片,则是—次取出—组连续的元素,相当于得到一个子列表

• 使用[ : ]的方式进行切片操作。

alist = [1, 2, 3, 4]
print(alist[1:3])

alist[1:3]中的1:3表示的是[1，3)这样的由下标构成的前闭后开区间。
也就是从下标为1的元素开始(2),到下标为3的元素结束(4),但是不包含下标为3的元素，所以最终结果只有2，3

• 切片操作中可以省略前后边界

alist = [1, 2, 3, 4]
print(alist[1:])
#省略后边界，表示获取到列表末尾
print(alist[:-1])
#省略前边界，表示从列表开头获取
print(alist[:])
#省略两个边界，表示获取到整个列表。

• 切片操作还可以指定“步长”,也就是""每访问—个元素后,下标自增几步”

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::5])

这里再多加一个:，再多加一个数字，这个数字就是步长。

步长的数值还可以是负数，当步长为负数的时候，意思是从后往前来取元素

当切片中的范围超出有效下标之后，不会出现异常！而是尽可能的把符合要求的元素获取到：

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[1:100])

切片操作是一个比较高效的操作,进行切片的时候,只是取出了原有列表中的一个部分,并不涉及到"数据的拷贝假设有一个很大的列表,进行切片,切片的范围也很大,即使如此,切片操作仍然非常高效.

遍历列表元素

1. 使用for循环进行遍历

a = 1, 2, 3, 4, 5
for elem in a:
    print(elem)

对elem修改，不会影响a列表。

2. 使用for循环遍历，通过下标的方式

a = 1, 2, 3, 4, 5
for i in range(0,len(a)):
    print(a[i])

3. 使用while循环，通过下标遍历

a = 1, 2, 3, 4, 5
i = 0
while i < len(a):
    print(a[i])

新增元素

• 使用append方法,向列表末尾插入一个元素(尾插)。

alist = [1, 2, 3, 4]
alist.append('he11o')
print(alist)

此处的append是搭配列表对象a，来一起使用的，而不是作为一个独立的函数

type，print，input，len这些自定义函数都是独立的函数，这种要搭配对象来使用的函数，也叫做方法

• 使用insert方法,向任意位置插入—个元素

  insert第一个参数表示要插入元素的下标。

alist = [1, 2, 3, 4]
alist.insert(1, "hello")
alist.insert(100, "hello")
print(alist)

什么是"方法”？(method)

方法其实就是函数.只不过函数是独立存在的，而方法往往要依附于某个"对象".
像上述代码 alist.append , append就是依附于alist,相当于是““针对alist这个列表,进行尾插操作”

查找元素

• 使用in操作符，判断元素是否在列表中存在，返回值是布尔类型。

alist = [1, 2, 3, 4]
print(2 in alist)
print(5 in alist)

print(1 not in alist)
#若1不在alist当中，则返回True，否则返回false
print(5 not in alist)

• 使用index方法，查找元素在列表中的下标，返回值是一个整数(下标)，如果元素不存在，则会抛出异常

alist = [1, 2, 3, 4]
print(alist.index(2))
print(alist,index(5))

删除元素

1. 使用pop删除列表中最末尾的元素

alist = [1, 2, 3, 4]
alist.pop()
print(alist)

2. 使用pop还能删除任意位置的元素，pop的参数可以传一个下标过去

alist = [1, 2, 3, 4]
alist.pop(1)
print(alist)

3. 使用remove方法，可以按照值来进行删除

a = ['aa', 'bb', 'cc', 'dd']
a.remove('cc')
print(a)

连接列表

• 使用＋能够把两个列表拼接在—起。

此处的+结果会生成一个新的列表，而不会影响到旧列表的内容.

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
print(alist + blist)

• 使用extend方法,相当于把一个列表拼接到另一个列表的后面。

a.extend(b)，是把b中的内容拼接到a的末尾，不会修改b，但是会修改a。

alist = [1, 2, 3, 4]
b1ist = [5, 6, 7]
alist.extend(blist)
print(alist)
print(blist)

None这是一个特殊的变量的值，表示"啥都没有"。

• 使用+=进行拼接

alist = [1, 2, 3, 4]
b1ist = [5, 6, 7]
alist += blist
print(alist)
print(blist)

看似和extend执行结果一样，但是执行的过程是有差别的，a += b，等价于a = a + b，a += b会首先创建更大的空间来保存a + b，然后再将a + b赋值给a，a的旧值会释放。而extend操作只是将b的值附加到a的末尾了。extend的开销更小一些。

关于元组

元组的功能和列表相比,基本是一致的。

元组使用()来表示。

atuple = ()
atuple = tuple()

元组不能修改里面的元素,列表则可以修改里面的元素

因此,像读操作,比如访问下标切片,遍历, in, index,+等,元组也是一样支持的。

但是，像写操作，比如修改元素,新增元素,删除元素, extend等,元组则不能支持。

另外，元组在 Python中很多时候是默认的集合类型，例如,当一个函数返回多个值的时候。

def 以上是关于Python基础语法的主要内容，如果未能解决你的问题，请参考以下文章
 
 Python入门 —— 02基础语法
 Python 语法基础_数据类型补充
 SQL语法练习
 Python-基础-Chpater3
 python基础练习。
 python基础列表方法汇总