本教程的知识点为：计算机组成 计算机是由什么组成的？ 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/嘿马python基础入门全体系教程/note.md
感兴趣的小伙伴可以自取哦~
全套教程部分目录：
部分文件图片：
多函数程序的基本使用流程
一般在实际开发过程中，一个程序往往由多个函数（后面知识中会讲解类）组成，并且多个函数共享某些数据，这种场景是经常出现的，因此下面来总结下，多个函数中共享数据的几种方式
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始终指向同一个地址
139935