头图

本教程的知识点为:计算机组成 计算机是由什么组成的? 1. 硬件系统: 2. 软件系统: 目标 运算符的分类 1. 算数运算符 2. 赋值运算符 3. 复合赋值运算符 判断语句和循环语句 if嵌套 1. if嵌套的格式 2. if嵌套的应用 if嵌套执行流程 容器:字符串、列表、元组、字典 字符串介绍 一. 认识字符串 1.1 字符串特征 字符串输出 容器:字符串、列表、元组、字典 列表的相关操作 1添加元素("增"append, extend, insert)1 append extend 容器:字符串、列表、元组、字典 字典的常见操作1 1查看元素1 2修改元素2 3添加元素3 函数介绍 1什么是函数1 小总结: 函数定义和调用 1定义函数1 多函数程序的基本使用流程 1. 使用全局变量 2. 使用函数的返回值、参数 3. 函数嵌套调用 函数返回值(二) 函数应用:学生管理系统 递归函数 1什么是递归函数1 2递归函数的作用2 看阶乘的规律 文件操作介绍 1什么是文件1 2文件的作用2 文件的打开与关闭 1打开文件1 面向对象编程介绍 面向对象 1. 概述 2. 生活举例 类和对象 __init__()方法 说明: 问题: 有参数的__init__()方法 说明: 继承介绍以及单继承 1. 现实中的继承 2. 程序中的继承 单继承:子类只继承一个父类 说明: super()的使用 问题: 知识点: 私有权限 面向对象三大特性:封装、继承、多态 静态方法和类方法 1. 类方法 2. 静态方法 总结 异常 模块 1Python中的模块1 2import2 3from…import3 注意

完整笔记资料代码:https://gitee.com/yinuo112/Backend/tree/master/Python/嘿马pyt...

感兴趣的小伙伴可以自取哦~


全套教程部分目录:


部分文件图片:

多函数程序的基本使用流程

一般在实际开发过程中,一个程序往往由多个函数(后面知识中会讲解类)组成,并且多个函数共享某些数据,这种场景是经常出现的,因此下面来总结下,多个函数中共享数据的几种方式

1. 使用全局变量

g_num = 0

def test1():
    global g_num
    # 将处理结果存储到全局变量g_num中.....
    g_num = 100

def test2():
    # 通过获取全局变量g_num的值, 从而获取test1函数处理之后的结果
    print(g_num)

  
  
# 1. 先调用test1得到数据并且存到全局变量中
  
  
test1()

  
  
# 2. 再调用test2,处理test1函数执行之后的这个值
  
  
test2()

2. 使用函数的返回值、参数

def test1():
     # 通过return将一个数据结果返回
     return 50

def test2(num):
    # 通过形参的方式保存传递过来的数据,就可以处理了
    print(num)

  
  
# 1. 先调用test1得到数据并且存到变量result中
  
  
result = test1()

  
  
# 2. 调用test2时,将result的值传递到test2中,从而让这个函数对其进行处理
  
  
test2(result)

3. 函数嵌套调用

def test1():
    # 通过return将一个数据结果返回
    return 20

def test2():
    # 1. 先调用test1并且把结果返回来
    result = test1()
    # 2. 对result进行处理
    print(result)

  
  
# 调用test2时,完成所有的处理
  
  
test2()

函数返回值(二)

在python中我们怎样返回多个值?

<1> 多个return?1>

def create_nums():
    print("---1---")
    return 1  # 函数中下面的代码不会被执行,因为return除了能够将数据返回之外,还有一个隐藏的功能:结束函数
    print("---2---")
    return 2
    print("---3---")
总结1:
  • 一个函数中可以有多个return语句,但是只要有一个return语句被执行到,那么这个函数就会结束了,因此后面的return没有什么用处
  • 如果程序设计为如下,是可以的因为不同的场景下执行不同的return
def create_nums(num):
      print("---1---")
      if num == 100:
          print("---2---")
          return num+1  # 函数中下面的代码不会被执行,因为return除了能够将数据返回之外,还有一个隐藏的功能:结束函数
      else:
          print("---3---")
          return num+2
      print("---4---")

  result1 = create_nums(100)
  print(result1)  # 打印101
  result2 = create_nums(200)
  print(result2)  # 打印202

<2> 一个函数返回多个数据的方式2>

def divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu  #默认是元组

result = divid(5, 2)
print(result)  # 输出(2, 1)
总结2:
  • return后面可以是元组,列表、字典等,只要是能够存储多个数据的类型,就可以一次性返回多个数据

    def function():
            # return [1, 2, 3]
            # return (1, 2, 3)
            return {"num1": 1, "num2": 2, "num3": 3}
  • 如果return后面有多个数据,那么默认是元组
In [1]: a = 1, 2
      In [2]: a
      Out[2]: (1, 2)

      In [3]:
      In [3]: b = (1, 2)
      In [4]: b
      Out[4]: (1, 2)

      In [5]:

函数参数(二)

<1>. 位置参数1>

位置参数:调用函数时根据函数定义的参数位置来传递参数。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20, '男')
注意:传递和定义参数的顺序及个数必须一致。

<2>. 关键字参数2>

函数调用,通过“键=值”形式加以指定。可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

注意:函数调用时,如果有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序。

<3>. 缺省参数3>

调用函数时,缺省参数的值如果没有传入,则取默认值。

下例会打印默认的age,如果age没有被传入:

def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)
   print("age %d" % age)

  
  
# 调用printinfo函数
  
  
printinfo(name="miki")  # 在函数执行过程中 age去默认值35
printinfo(age=9 ,name="miki")

以上实例输出结果:

name: miki
age: 35
name: miki
age: 9
总结:
  • 在形参中默认有值的参数,称之为缺省参数
  • 注意:带有默认值的参数一定要位于参数列表的最后面

    >>> def printinfo(name, age=35, sex):
    ...     print name
    ...
      File "<stdin>", line 1
    SyntaxError: non-default argument follows default argument

<4>. 不定长参数4>

有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数,声明时不会命名。

基本语法如下:

def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]
注意:
  • 加了星号(*)的变量args会存放所有未命名的变量参数,args为元组
  • 而加**的变量kwargs会存放命名参数,即形如key=value的参数, kwargs为字典.
>>> def fun(a, b, *args, **kwargs):
...     """可变参数演示示例"""
...     print("a =%d" % a)
...     print("b =%d" % b)
...     print("args:")
...     print(args)
...     print("kwargs: ")
...     for key, value in kwargs.items():
...         print("key=%s" % value)
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
a = 1
b = 2
args:
(3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d)    # 注意元组与字典的传参方式
a = 1
b = 2
args:
(3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args:
((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>

<5>. 缺省参数在*args后面5>

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)
说明:
  • 如果很多个值都是不定长参数,那么这种情况下,可以将缺省参数放到 *args的后面, 但如果有kwargs的话,kwargs必须是最后的

拆包、交换变量的值

<1> 对返回的数据直接拆包1>

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age


  
  
# result = get_my_info()
  
  
  
  
# print(result)
  
  

my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)
总结:
  • 拆包时要注意,需要拆的数据的个数要与变量的个数相同,否则程序会异常
  • 除了对元组拆包之外,还可以对列表、字典等拆包
In [17]: a, b = (11, 22)
  In [18]: a
  Out[18]: 11
  In [19]: b
  Out[19]: 22

  In [20]: a, b = [11, 22]
  In [21]: a
  Out[21]: 11
  In [22]: b
  Out[22]: 22

  In [23]: a, b = {"m":11, "n":22}  # 取出来的是key,而不是键值对
  In [24]: a
  Out[24]: 'm'
  In [25]: b
  Out[25]: 'n'

<2> 交换2个变量的值2>

  
  
# 第1种方式
  
  
  
  
# a = 4
  
  
  
  
# b = 5
  
  
  
  
# c = 0
  
  
  
  
#
  
  
  
  
# c = a
  
  
  
  
# a = b
  
  
  
  
# b = c
  
  
  
  
#
  
  
  
  
# print(a)
  
  
  
  
# print(b)
  
  

  
  
# 第2种方式
  
  
  
  
# a = 4
  
  
  
  
# b = 5
  
  
  
  
# a = a+b  # a=9, b=5
  
  
  
  
# b = a-b  # a=9, b=4
  
  
  
  
# a = a-b  # a=5, b=4
  
  
  
  
# print(a)
  
  
  
  
# print(b)
  
  

  
  
# 第3种方式
  
  
a, b = 4, 5
a, b = b, a

print(a)
print(b)

引用(一)

想一想

>>> a = 1
>>> b = a
>>> b
1
>>> a = 2
>>> a
2
请问此时b的值为多少?
>>> a = [1, 2]
>>> b = a
>>> b
[1, 2]
>>> a.append(3)
>>> a
[1, 2, 3]
请问此时b的值又是多少?

引用

在python中,值是靠引用来传递来的。

我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。

>>> a = 1
>>> b = a
>>> id(a) 
13033816
>>> id(b)   # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a)   # 注意a的id值已经变了
13033792
>>> id(b)   # b的id值依旧
13033816
>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)       # 注意a与b始终指向同一个地址
139935018544808

引用原理

总结:
  • 之前为了更好的理解变量,咱们可以把a=100理解为变量a中存放了100,事实上变量a存储是100的引用(可理解为在内存中的一个编号)

引用(二)

引用当做实参

  • 可变类型与不可变类型的变量分别作为函数参数时,会有什么不同吗?
  • Python有没有类似C语言中的指针传参呢?

程序员一诺python
16 声望16 粉丝

python技术发烧友 资料收集狂