2022年 11月 8日

Python菜鸟教程学习笔记

菜鸟教程Python3学习笔记

  • 基础语法
    • 编码
    • 标识符
    • Python保留字
    • 注释
    • 行与缩进
    • 多行语句
    • 数字类型
    • 字符串
    • 输入
    • print输出
    • 导入模块
  • 基础数据类型
    • 多个变量的赋值
    • 标准数据类型
    • 数值运算
    • String
    • List
    • Tuple
    • Set
    • Dictionary
  • 注释
  • 运算符
    • 算术运算符
    • 赋值运算符
    • 位运算符
    • 逻辑运算符
    • 成员运算符
    • 身份运算符
  • 数字(Number)
    • 数字类型转换
    • 数字运算
  • 字符串
    • 访问字符串中的值
    • 字符串更新
    • 字符串运算符
    • 字符串格式化
    • 转义字符
    • 三引号
    • f-string
  • 列表
    • 访问列表中的值
    • 更新列表
    • 删除列表
    • 列表脚本操作符
    • 列表截取与拼接
    • 嵌套列表
  • 元组
    • 访问元组
    • 修改元组
    • 删除元组
  • 字典
    • 访问字典里的值
    • 修改字典
    • 删除字典元素
    • 字典键的特性
  • 集合
    • 集合的基本操作
      • 添加元素
      • 删除元素
      • 计算集合的元素个数
      • 清空元素
      • 判断元素是否在集合中存在
  • 条件控制
  • 循环语句
    • while循环
    • for循环
    • range()函数
    • break语句
    • continue语句
    • pass语句
  • 迭代器和生成器
    • 迭代器
    • 生成器
  • 函数
    • 定义一个函数
    • 参数传递
      • 传不可变对象实例
      • 传可变对象实例
    • 参数
      • 必须参数
      • 关键字参数
      • 默认参数
      • 不定长参数
    • return 语句
  • 错误和异常
  • 面向对象
    • 面向对象技术简介
    • 类定义
    • 类对象
    • 类的方法
    • 继承
    • 多继承
    • 方法重写
    • 类属性与方法
      • 类的私有属性
      • 类的方法
      • 类的私有方法
    • 类的专有方法
    • 运算符重载

基础语法

编码

Python源码文件默认以UTF-8编码,Python所有字符串都是Unicode字符串,不过我们也可以为源码文件指定不同的编码。例如:

# -*- coding: cp-1252 -*-
  • 1

标识符

几乎所有语言都有自己的标识符命名规则,Python也不例外。
1.Python的标识符必须以下划线或者字母开头
2.标识符的其他部分由字母、数字和下划线组成
3.Python区分大小写

Python保留字

保留字也就是关键字,由Python官方保留而不提供给用户进行给任何标识符命名。用以下方法可以查看Python的所有保留字:

import keyword
print(keyword.kwlist)
  • 1
  • 2

注释

Python单行注释可以用 # 来实现,而多行注释则可以用三引号 ‘’’“”” 来实现(这里引号要用英文符号)

# 第一个注释

'''
这是一个多行注释
用三引号实现
'''

"""
当然还可以用这种方式实现
还不错吧
"""
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

行与缩进

python不像Java、C++等语言使用大括号{}来区分代码块,而是采用缩进的方法,缩进的空格数没有具体要求,但是一定要保持一致。

if True:
    print("true")
else:
    print("false")
  • 1
  • 2
  • 3
  • 4

错误的缩进格式可能会导致错误

if True:
    print("Answer")
    print("True")
else:
    print("false")
  print("false")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

多行语句

多行语句可以用反斜杠 \ 来实现

item_one = item_two = item_three = 1
total = item_one + \
        item_two + \
        item_three
print(total)
  • 1
  • 2
  • 3
  • 4
  • 5

在[],{},()中的多行语句,不需要使用反斜杠\,例如:

total = {'item_one', 'item_two', 'item_three',
         'item_four', 'item_five'}
  • 1
  • 2

数字类型

python有四种数字类型:整数、布尔型、浮点数和复数
int (整数), 如 1, 只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
bool (布尔), 如 True。
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j

字符串

  • python中单引号和双引号使用完全相同。
  • 使用三引号(’’’ 或 “””)可以指定一个多行字符串。
  • 转义符 \
  • 反斜杠可以用来转义,使用r可以让反斜杠不发生转义。。 如 r”this is a line with \n” 则\n会显示,并不是换行。
  • 按字面意义级联字符串,如”this ” “is ” “string”会被自动转换为this is string。
  • 字符串可以用 + 运算符连接在一起,用 * 运算符重复。
  • Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。
  • Python中的字符串不能改变。
  • Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。
  • 字符串的截取的语法格式如下:变量[头下标:尾下标:步长]
word = '这是一个字符串'
sentence = '这是一个句子。'
paragraph = """这是一个段落,
可以由多行内容组成"""

str = '123456789'

print(str)  # 输出字符串
print(str[0:-1])  # 输出第一个字符到倒数第二个字符
print(str[0])  # 输出第一个字符
print(str[2:5])  # 输出第三到第五个字符
print(str[2:])  # 输出第三个字符到最后一个字符
print(str[1:5:2])  # 从第二个字符开始,每隔一个字符输出一次,输出到第五个字符
print(str * 2)  # 重复输出两次字符串
print(str + '你好')  # 连接字符串并输出

print('-----------------------------')

print('hello\nrookie')  # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')  # 在字符串前面添加一个 r,表示原始字符串,不会发生转义

print("\n")  # 换行
print(r"\n")  # 输出\n
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

输入

python中使用input()函数来获取用户输入的数据

text = input("请用户输入信息:")
  • 1

print输出

print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=””:

x = "a"
y = "b"
# 换行输出
print(x)
print(y)

print("-----------------------------")
# 不换行输出
print(x, end="")
print(y, end="")
print()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

导入模块

  • 在 python 用 import 或者 from…import 来导入相应的模块。
  • 将整个模块(somemodule)导入,格式为: import somemodule
  • 从某个模块中导入某个函数,格式为: from somemodule import somefunction
  • 从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
  • 将某个模块中的全部函数导入,格式为: from somemodule import *

基础数据类型

python中的变量不需要声明,不像Java、C++等编程语言需要在使用之前进行变量声明。但是每个变量在使用之前必须要赋值,只有被赋值以后,这个变量才创建完成。

name = "Jack Hokkiens"  # 字符串
num = 623  # 整形变量
is_real = True  # 布尔型变量
price = 28.50  ## 浮点型变量
  • 1
  • 2
  • 3
  • 4

多个变量的赋值

Python中可以一次为多个变量赋同一个值,也可以一次为多个变量赋不同的值,另外数据类型还可以不相同。

var_1, var_2, var_3 = 25.75, "rookie", True
var_4 = var_5 = var_6 = 860
  • 1
  • 2

标准数据类型

python中的标准数据类型有Number、String、List、Tuple、Set以及Dictionary。
type()可以用来查询变量所指的对象类型
isinstance() 和 type()的不同之处
type()不认为子类是一种父类类型
isinstance()会认为子类是一种父类类型

t = 369
print(isinstance(t, int))


class A:
    pass


class B(A):
    pass


print(isinstance(A(), A))
print(type(A()) == A)
print(isinstance(B(), A))
print(type(B()) == A)

# 在Python中 bool 是 int 的子类
print(issubclass(bool, int))
print((True == 1))
print((False == 0))
print(True + 1)
print(False + 1)
print(1 is True)
print(0 is False)
print(True is 1)
print(True is int)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
# 当我们指定一个值时,Number对象就会被创建:
var1 = 2
var2 = 35
print(var1, var2)
# 使用del语句可以删除对象的引用
del var1, var2
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

数值运算

python的数值运算和其他语言并没有多大的区别

num1, num2 = 50, 31
print(num1 + num2)  # 加法
print(num1 - num2)  # 减法
print(num1 * num2)  # 乘法
print(num1 / num2)  # 得到的结果为浮点数
print(num1 // num2)  # 整除
print(num1 % num2)  # 取余
print(num1 ** 2)  # 乘方
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

String

String的总结大概就是前面基础语法的那些了

List

  • List(列表),List是Python中一种集合类的数据类型,与其他语言的数组类型不同,List可以存储不同类型的数据。
  • List是写在方括号[]中,用逗号,隔开的元素列表。List和字符串一样,可以被截取,返回的结果就是包含所需元素的新列表
list_1 = ['Jackson', 150, 28.90, True, "Lucy"]
list_2 = [86, "James"]

print(list_1)
print(list_2)
print(list_1[0])
print(list_1[1:3])
print(list_1[2:])
print(list_2 * 2)
print(list_1 + list_2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
# 与字符串不同,Python中的列表中的元素是可以改变的
a = [1, 2, 3, 4, 5, 6]
a[0] = 9
a[2:5] = [13, 14, 15]
print(a)
# 列表的元素也可以按固定步长来取
b = "HelloPython"
print(b[1:8:2])
a[2:5] = []
print(a)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
# 逆向读取或逆向反转
list_1 = [1, 2, 3, 4]
print(list_1[-1::-1])
list_2 = list_1[-1::-1]
list_3 = "I Love You"
output_str = ''.join(list_3[-1::-1])
print(output_str)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Tuple

  • Tuple(元组),与列表相似,但是元组中的元素不能更改。元组写在小括号()中,元素用逗号,隔开。元组中元素类型也可以不同
tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')

print(tuple)  # 输出完整元组
print(tuple[0])  # 输出元组的第一个元素
print(tuple[1:3])  # 输出从第二个元素开始到第三个元素
print(tuple[2:])  # 输出从第三个元素开始的所有元素
print(tinytuple * 2)  # 输出两次元组
print(tuple + tinytuple)  # 连接元组

# 虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
# 构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
tup1 = ()    # 空元组
tup2 = (20,)  # 一个元素,需要在元素后添加逗号
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

Set

  • 集合(set)是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员。
  • 注意集合中不存在重复的元素.基本功能是进行成员关系测试和删除重复元素。
  • 可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
  • 创建格式:
    parame = {value01,value02,…}或者set(value)
players = {'Kobe', 'LeBron', 'Harden', 'Curry', 'Durant', 'Green'}

print(players)  # 输出集合,重复的元素被自动去掉

# 成员测试
if 'Curry' in players:
    print('Curry 在集合中')
else:
    print('Curry 不在集合中')

# # set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)  # a 和 b 的差集
print(a | b)  # a 和 b 的并集
print(a & b)  # a 和 b 的交集
print(a ^ b)  # a 和 b 中不同时存在的元素
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

Dictionary

  • 字典(dictionary)是Python中另一个非常有用的内置数据类型。
  • 列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
  • 字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合。
  • 键(key)必须使用不可变类型。
  • 在同一个字典中,键(key)必须是唯一的。

1、字典是一种映射类型,它的元素是键值对。
2、字典的关键字必须为不可变类型,且不能重复。
3、创建空字典使用 { }。

dict = {}
dict["MVP"] = "Curry"
dict[2] = "对应键为2的属性值"

tinydict = {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}

print(dict['MVP'])  # 输出键为 'one' 的值
print(dict[2])  # 输出键为 2 的值
print(tinydict)  # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values())  # 输出所有值
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
# 构造函数 dict() 可以直接从键值对序列中构建字典如下:
# 第一种方法
player_dict = dict([('Kobe', 'Byrant'), ('Stephen', 'Curry'), ('Jordan', 6)])
print(player_dict)
# # 第二种方法
chengFang_dict = {x: x ** 2 for x in (2, 4, 6)}
print(chengFang_dict)
# # 第三种方法
dict_example = dict(Runoob=1, Google=2, Taobao=3)
print(dict_example)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

注释

  • python中有单行注释和多行注释
  • 单行注释使用 # 来实现
  • 多行注释使用 ‘’’ 或 “”” 来实现
# 这是一个单行注释
print("Hello Python")

'''
这是一个多行注释
多行注释的第一种风格
'''
print("Hello Python")

"""
这是一个多行注释
多行注释的第二种风格
"""
print("Hello Python")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

运算符

算术运算符

与其他编程语言没什么不同

a = 45
b = 8
print("a + b = ", a + b)
print("a - b = ", a - b)
print("a * b = ", a * b)
print("a / b = ", a / b)
print("a // b = ", a // b)
print("a % b = ", a % b)
print("b ** 2 = ", b ** 2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

赋值运算符

也是大同小异

c = 12
d = 4
e = 0
e = c + d
print("e = ", e)
e += c
print("e = ", e)
e -= c
print("e = ", e)
e *= c
print("e = ", e)
e /= c
print("e = ", e)
e //= c
print("e = ", e)
e %= c
print("e = ", e)
e **= d
print("e = ", e)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

位运算符

a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0

c = a & b  # 12 = 0000 1100
print("1 - c 的值为:", c)

c = a | b  # 61 = 0011 1101
print("2 - c 的值为:", c)

c = a ^ b  # 49 = 0011 0001
print("3 - c 的值为:", c)

c = ~a  # -61 = 1100 0011
print("4 - c 的值为:", c)

c = a << 2  # 240 = 1111 0000
print("5 - c 的值为:", c)

c = a >> 2  # 15 = 0000 1111
print("6 - c 的值为:", c)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

逻辑运算符

也是大同小异,看代码吧

a = 10
b = 20

if (a and b):
    print("1 - 变量 a 和 b 都为 true")
else:
    print("1 - 变量 a 和 b 有一个不为 true")

if (a or b):
    print("2 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值
a = 0
if a and b:
    print("3 - 变量 a 和 b 都为 true")
else:
    print("3 - 变量 a 和 b 有一个不为 true")

if a or b:
    print("4 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:
    print("4 - 变量 a 和 b 都不为 true")

if not (a and b):
    print("5 - 变量 a 和 b 都为 false,或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

成员运算符

成员运算符用来判断一个变量是否在序列中,也就是是否为其成员之一

# Python成员运算符
a = 10
b = 20
list = [1, 2, 3, 4, 5]

if (a in list):
    print("1 - 变量 a 在给定的列表中 list 中")
else:
    print("1 - 变量 a 不在给定的列表中 list 中")

if (b not in list):
    print("2 - 变量 b 不在给定的列表中 list 中")
else:
    print("2 - 变量 b 在给定的列表中 list 中")

# 修改变量 a 的值
a = 2
if (a in list):
    print("3 - 变量 a 在给定的列表中 list 中")
else:
    print("3 - 变量 a 不在给定的列表中 list 中")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

身份运算符

a = 20
b = 20

if (a is b):
    print("1 - a 和 b 有相同的标识")
else:
    print("1 - a 和 b 没有相同的标识")

if (id(a) == id(b)):
    print("2 - a 和 b 有相同的标识")
else:
    print("2 - a 和 b 没有相同的标识")

# 修改变量 b 的值
b = 30
if (a is b):
    print("3 - a 和 b 有相同的标识")
else:
    print("3 - a 和 b 没有相同的标识")

if (a is not b):
    print("4 - a 和 b 没有相同的标识")
else:
    print("4 - a 和 b 有相同的标识")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

数字(Number)

  • Python 数字数据类型用于存储数值。
  • 数据类型是不允许改变的,这就意味着如果改变数字数据类型的值,将重新分配内存空间。
  • 整型(int) – 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
  • 浮点型(float) – 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250)
  • 复数( (complex)) – 复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。

数字类型转换

# Python数字类型转换
a = 3.0
b = int(a)
print(b)
c = float(b)
print(c)

number1 = 0xA0F  # 十六进制
print(number1)
number2 = 0o37  # 八进制
print(number2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

数字运算

与其他编程语言没有多大区别,总结如上面运算符的内容

字符串

  • 字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 ” )来创建字符串。
  • 创建字符串很简单,只要为变量分配一个值即可。例如:
var1 = "Hello"
var2 = "Python"
  • 1
  • 2

访问字符串中的值

Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串,可以使用方括号 [] 来截取字符串,字符串的截取的语法格式如下:

# Python 访问字符串中的值
print("var1[0] = ", var1[0])
print("var2[2:5] = ", var2[2:5])
  • 1
  • 2
  • 3

字符串更新

var1 = 'Hello World!'
print("已更新字符串 : ", var1[:6] + 'Runoob!')
  • 1
  • 2

字符串运算符

a = "Hello"
b = "JQJQJQ"

print("a + b 输出结果:", a + b)
print("a * 2 输出结果:", a * 2)
print("a[2] 输出结果:", a[2])
print("a[1:4] 输出结果:", a[1:4])

if "H" in a:
    print("H 在变量 a 中")
else:
    print("H 不在变量 a 中")

if "M" not in a:
    print("M 不在变量 a 中")
else:
    print("M 在变量 a 中")
print(r'\n')
print(R'\n')
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

字符串格式化

print("我叫 %s ,今年 %d 岁了" % ('猪猪', 18))
  • 1

转义字符

与其他编程语言大致相同,可以查看Python转义字符

三引号

str1 = """三引号可以允许
一个字符串跨越多行,
还可以包括制表符(\t)
以及换行符(\n)
"""
print(str1)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

f-string

f-string是python后续推出的更方便的字符串格式化方式,f-string 格式化字符串以 f 开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去,实例如下:

# f-string
name = 'Jackson'
print(f"Hello {name}")
print(f"{1 + 2}")

w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print(f'{w["name"]}', f'{w["url"]}')

x = 1
print(f'{x+1}')   # Python 3.6
x = 1
print(f'{x+1=}')   # Python 3.8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

列表

  • 列表是最常用的 Python 数据类型,它可以作为一个方括号内的逗号分隔值出现。
  • 列表的数据项不需要具有相同的类型
  • 创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示:
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
  • 1
  • 2
  • 3
  • 4

访问列表中的值

# 访问列表中的值
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list[0])
print(list[1])
print(list[2])
  • 1
  • 2
  • 3
  • 4
  • 5

反向索引

# 反向索引
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list[-1])
print(list[-2])
print(list[-3])
  • 1
  • 2
  • 3
  • 4
  • 5

对列表进行截取

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
# 也可以用负数索引值进行截取
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]

# 读取第二位
print("list[1]: ", list[1])
# 从第二位开始(包含)截取到倒数第二位(不包含)
print("list[1:-2]: ", list[1:-2])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

更新列表

list = ['Johnson', 'Rookie', 1998, True]
print("第二个元素是:", list[1])
# 修改列表
list[1] = 'LeBron'
print("更新后的第二个元素是:", list[1])

list2 = ['Doinb', 'Lwx', 'Crisp']
list2.append('Tian')
print(list2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

删除列表

可以通过使用del语句删除列表中的元素

# 删除列表元素可以使用del语句
list = ['Johnson', 'Rookie', 1998, True]
print("原始列表:", list)
# 删除第二个元素
del list[1]
print("删除第二个元素后的列表:", list)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。

list1 = ['Chicken', 'Beef', 'Pork']
print("list1的长度是:", len(list1))
list2 = ['Apple', 'StrawBerry']
list3 = list1 + list2
print(list3)
list4 = list1 * 2
print(list4)
for x in list1:
    print(x, end=" ")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

列表截取与拼接

list1 = ['Chicken', 'Beef', 'Pork']
list2 = list1[0:2]
print(list2)
list1 += ['Apple', 'StrawBerry']
print(list1)
  • 1
  • 2
  • 3
  • 4
  • 5

嵌套列表

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)
print(x[0])
print(x[0][1])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

元组

  • Python 的元组与列表类似,不同之处在于元组的元素不能修改。
  • 元组使用小括号 ( ),列表使用方括号 [ ]。
  • 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   #  不需要括号也可以
print(type(tup3))
  • 1
  • 2
  • 3
  • 4
# 创建空元组
tup1 = ()
  • 1
  • 2

元组中只包含一个元素时,需要在元素后面添加逗号 , ,否则括号会被当作运算符使用:

tup1 = (50)
print(type(tup1))  # 不加逗号,类型为整型

tup1 = (50,)
print(type(tup1))  # 加上逗号,类型为元组
  • 1
  • 2
  • 3
  • 4
  • 5

访问元组

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])
  • 1
  • 2
  • 3
  • 4
  • 5

修改元组

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

删除元组

tup = ('Google', 'Runoob', 1997, 2000)

print(tup)
del tup
print("删除后的元组 tup : ")
print(tup)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

字典

  • 字典是另一种可变容器模型,且可存储任意类型对象。
  • 字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中
    键必须是唯一的,但值则不必。
  • 值可以取任何数据类型,但键必须是不可变的,如字符串,数字。
  • 一个简单的字典实例:
dict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
  • 1

访问字典里的值

# 把相应的键放入到方括号中,如下实例:
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print("dict['Name']: ", dict['Name'])
print("dict['Age']: ", dict['Age'])

# 如果用字典里没有的键访问数据,会输出错误如下:
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print("dict['Alice']: ", dict['Alice'])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

修改字典

# 向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8  # 更新 Age
dict['School'] = "菜鸟教程"  # 添加信息

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

删除字典元素

# 能删单一的元素也能清空字典,清空只需一项操作。
# 显示删除一个字典用del命令,如下实例:
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name']  # 删除键 'Name'
dict.clear()  # 清空字典
del dict  # 删除字典

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

字典键的特性

字典值可以是任何的 python 对象,既可以是标准的对象,也可以是用户定义的,但键不行。
两个重要的点需要记住:
1)不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:

dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print("dict['Name']: ", dict['Name'])
  • 1
  • 2

2)键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下实例:

dict = {['Name']: 'Runoob', 'Age': 7}
print("dict['Name']: ", dict['Name'])
  • 1
  • 2

集合

  • 集合(set)是一个无序的不重复元素序列。
  • 可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # 这里演示的是去重功能
print('orange' in basket)  # 快速判断元素是否在集合内
print('crabgrass' in basket)
# 两个集合之间的运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)  # 集合a中包含而集合b中不包含的元素
print(a | b)  # 集合a或b中包含的所有元素
print(a & b)  # 集合a和b中都包含了的元素
print(a ^ b)  # 不同时包含于a和b的元素
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
# 推导式,同样集合支持集合推导式(Set comprehension):
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
  • 1
  • 2
  • 3

集合的基本操作

添加元素

# 1、添加元素
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset)
  • 1
  • 2
  • 3
  • 4
# 也可以采用如下方法添加元素
thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({1, 3})
print(thisset)
thisset.update([1, 4], [5, 6])
print(thisset)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

删除元素

# 2、移除元素
thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print(thisset)

# thisset.remove("Facebook")  # 不存在会发生错误
# 此外还有一个方法也是移除集合中的元素,且如果元素不存在,不会发生错误。格式如下所示:
thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook")  # 不存在不会发生错误
print(thisset)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

也可以使用pop()来移除元素,不过这种方法可能每次得到的结果不同

# pop对集合删除元素有可能每次得到的结果不一定相同
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)
  • 1
  • 2
  • 3
  • 4
  • 5

计算集合的元素个数

# 计算集合元素个数
thisset = set(("Google", "Runoob", "Taobao"))
print(len(thisset))
  • 1
  • 2
  • 3

清空元素

# 清空集合
thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset)
  • 1
  • 2
  • 3
  • 4

判断元素是否在集合中存在

# 判断元素是否在集合中存在
thisset = set(("Google", "Runoob", "Taobao"))
print("Runoob" in thisset)
print("Facebook" in thisset)
  • 1
  • 2
  • 3
  • 4

条件控制

python中的条件控制是通过if语句来实现的,与其他编程语言一样,也可以进行if语句的嵌套。同时不同的是,python中将相同缩进的语句视为执行体的代码块。而且在Python中没有switch语句。

num = int(input("输入一个数字:"))
if num % 2 == 0:
    if num % 3 == 0:
        print("你输入的数字可以整除 2 和 3")
    else:
        print("你输入的数字可以整除 2,但不能整除 3")
else:
    if num % 3 == 0:
        print("你输入的数字可以整除 3,但不能整除 2")
    else:
        print("你输入的数字不能整除 2 和 3")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

循环语句

Python 中的循环语句有 for 和 while。

while循环

# while循环
n = 100

sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1

print("1 到 %d 之和为: %d" % (n, sum))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

无限循环,是条件永远为真即可

# 无限循环,使判断条件永远为真就好
var = 1
while var == 1:  # 表达式永远为 true
    num = int(input("输入一个数字  :"))
    print("你输入的数字是: ", num)

print("Good bye!")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

while循环使用else语句

# while循环使用else语句,如果 while 后面的条件语句为 false 时,则执行 else 的语句块。
count = 0
while count < 5:
    print(count, " 小于 5")
    count = count + 1
else:
    print(count, " 大于或等于 5")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

for循环

# for语句,Python for 循环可以遍历任何可迭代对象,如一个列表或者一个字符串。
languages = ["C", "C++", "Perl", "Python"]
for x in languages:
    print(x)
  • 1
  • 2
  • 3
  • 4

使用break语句可跳出循环

# 使用break语句,可以跳出当前循环
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

range()函数

# range()函数,如果你需要遍历数字序列,可以使用内置range()函数。它会生成数列,例如:
for i in range(5):
    print(i)

# 也可以指定区间
for i in range(5):
    print(i)

# 也可以使range以指定数字开始并指定不同的增量(甚至可以是负数,有时这也叫做'步长'):
for i in range(0, 10, 3):
    print(i)

# 负数步长
for i in range(-10, -100, -30):
    print(i)

# 结合len()
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i, a[i])

# 创建列表
list1 = list(range(5))
print(list1)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

break语句

# while中使用break语句
n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('循环结束。')
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

continue语句

# while中使用continue语句
n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环结束。')
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

pass语句

pass语句不做任何事情,可以理解为占位语句

# Python pass是空语句,是为了保持程序结构的完整性。
while True:
    pass
  • 1
  • 2
  • 3

迭代器和生成器

迭代器

  • 迭代是Python最强大的功能之一,是访问集合元素的一种方式。
  • 迭代器是一个可以记住遍历的位置的对象。
  • 迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。
  • 迭代器有两个基本的方法:iter() 和 next()。
  • 字符串,列表或元组对象都可用于创建迭代器:
list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
print(next(it))  # 输出迭代器的下一个元素
print(next(it))
  • 1
  • 2
  • 3
  • 4

迭代器对象可以使用常规for语句进行遍历:

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
for x in it:
    print(x, end=" ")
  • 1
  • 2
  • 3
  • 4

也可以使用next()函数

import sys  # 引入 sys 模块

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象

while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

创建一个迭代器,把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x


myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

StopIteration 异常用于标识迭代的完成,防止出现无限循环的情况,
next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= 20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration


myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
    print(x)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

生成器

  • 生成器,在 Python 中,使用了 yield 的函数被称为生成器(generator)。
  • 跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
  • 在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
  • 调用一个生成器函数,返回的是一个迭代器对象。
import sys


def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1


f = fibonacci(10)  # f 是一个迭代器,由生成器返回生成

while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

函数

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。函数能提高应用的模块性,和代码的重复利用率。

定义一个函数

  • 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号 : 起始,并且缩进。
  • return [表达式] 结束函数,选择性地返回一个值给调用方,不带表达式的 return 相当于返回 None。
def max(a, b):
    if a > b:
        return a
    else:
        return b


a = 4
b = 5
print(max(a, b))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
# 计算面积函数
def area(width, height):
    return width * height


def print_welcome(name):
    print("Welcome", name)


print_welcome("JQJQ")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
# 定义函数
def printme(str):
    # 打印任何传入的字符串
    print(str)
    return
    
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

参数传递

可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。

  • 不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变 a 的值,相当于新生成了 a。
  • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。

python 函数的参数传递:

  • 不可变类型:类似 C++ 的值传递,如整数、字符串、元组。如 fun(a),传递的只是 a 的值,没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值,则是新生成一个 a 的对象。
  • 可变类型:类似 C++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后 fun 外部的 la 也会受影响

python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。

传不可变对象实例

# python 传不可变对象实例
def change(a):
    print(id(a))  # 指向的是同一个对象
    a = 10
    print(id(a))  # 一个新对象


a = 1
print(id(a))
change(a)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

传可变对象实例

# 传可变对象实例
def changeme(mylist):
    "修改传入的列表"
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return


# 调用changeme函数
mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

参数

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必须参数

  • 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
  • 调用 printme() 函数,你必须传入一个参数,不然会出现语法错误:
def printme(str):
    """打印任何传入的字符串"""
    print(str)
    return


# 调用 printme 函数,不加参数会报错
printme()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

关键字参数

  • 关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
  • 使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
def printinfo(name, age):
    """打印任何传入的字符串"""
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(age=18, name="JQJQ")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

默认参数

  • 调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入 age 参数,则使用默认值:
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

不定长参数

  • 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名
  • 加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。
def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    print(vartuple)


# 调用printinfo 函数
printinfo(70, 60, 50)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
# 不指定变长参数,则它就是一个空元组
def printinfo(arg1, *vartuple):
    """打印任何传入的参数"""
    print("输出: ")
    print(arg1)
    for var in vartuple:
        print(var)
    return
    
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
# 加了两个星号 ** 的参数会以字典的形式导入。
def printinfo(arg1, **vardict):
    """打印任何传入的参数"""
    print("输出: ")
    print(arg1)
    print(vardict)

# 调用printinfo 函数
printinfo(1, a=2,b=3)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
# 声明函数时,参数中星号 * 可以单独出现,如果单独出现星号 * 后的参数必须用关键字传入。
def f(a, b, *, c):
    return a + b + c


# f(1,2,3)   # 报错
f(1, 2, c=3)  # 正常
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

return 语句

# return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2
    print("函数内 : ", total)
    return total


# 调用sum函数
total = sum(10, 20)
print("函数外 : ", total)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

错误和异常

菜鸟教程错误和异常章节

面向对象

面向对象技术简介

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 方法:类中定义的函数。
  • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
  • 局部变量:定义在方法中的变量,只作用于当前实例的类。
  • 实例变量:在类的声明中,属性是用变量来表示的,这种变量就称为实例变量,实例变量就是一个用 self 修饰的变量。
  • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟”是一个(is-a)”关系(例图,Dog是一个Animal)。
  • 实例化:创建一个类的实例,类的具体对象。
  • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

类定义

语法格式如下:

class ClassName:
<statement-1>
.
.
.
<statement-N>
类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性。

类对象

  • 类对象支持两种操作:属性引用和实例化。
  • 属性引用使用和 Python 中所有的属性引用一样的标准语法:obj.name。
  • 类对象创建后,类命名空间中所有的命名都是有效属性名
class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为:", x.i)
print("MyClass 类的方法 f 输出为:", x.f())
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

类的方法

在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self, 且为第一个参数,self 代表的是类的实例。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

继承

  • 子类(派生类 DerivedClassName)会继承父类(基类 BaseClassName)的属性和方法。
  • BaseClassName(实例中的基类名)必须与派生类定义在一个作用域内。除了类,还可以用表达式,基类定义在另一个模块中时这一点非常有用:
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

多继承

  • 需要注意圆括号中父类的顺序,若是父类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时,从左到右查找父类中是否包含方法
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类,多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s,我是一个演说家,我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同,默认调用的是在括号中排前地父类的方法
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

方法重写

如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法,实例如下:

# 方法重写
class Parent:  # 定义父类
    def myMethod(self):
        print('调用父类方法')


class Child(Parent):  # 定义子类
    def myMethod(self):
        print('调用子类方法')


c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法
super(Child, c).myMethod()  # 用子类对象调用父类已被覆盖的方法
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

类属性与方法

类的私有属性

  • __private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

  • 在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。
  • self 的名字并不是规定死的,也可以使用 this,但是最好还是按照约定使用 self。

类的私有方法

  • __private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,不能在类的外部调用。self.__private_methods。
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错,实例不能访问私有变量
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

类的专有方法

  • init : 构造函数,在生成对象时调用
  • del : 析构函数,释放对象时使用
  • repr : 打印,转换
  • setitem : 按照索引赋值
  • getitem: 按照索引获取值
  • len: 获得长度
  • cmp: 比较运算
  • call: 函数调用
  • add: 加运算
  • sub: 减运算
  • mul: 乘运算
  • truediv: 除运算
  • mod: 求余运算
  • pow: 乘方

运算符重载

Python同样支持运算符重载,我们可以对类的专有方法进行重载,实例如下:

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14