Python菜鸟教程学习笔记

基础语法

编码

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

# -*- coding: cp-1252 -*-

标识符

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

Python保留字

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

import keyword
print(keyword.kwlist)

注释

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

# 第一个注释

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

"""
当然还可以用这种方式实现
还不错吧
"""

行与缩进

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

if True:
    print("true")
else:
    print("false")

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

if True:
    print("Answer")
    print("True")
else:
    print("false")
  print("false")

多行语句

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

item_one = item_two = item_three = 1
total = item_one + \
        item_two + \
        item_three
print(total)

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

total = {'item_one', 'item_two', 'item_three',
         'item_four', 'item_five'}

数字类型

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

输入

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

text = input("请用户输入信息：")

print输出

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

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

print("-----------------------------")
# 不换行输出
print(x, end="")
print(y, end="")
print()

导入模块

• 在 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  ## 浮点型变量

多个变量的赋值

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

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

标准数据类型

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)

# 当我们指定一个值时，Number对象就会被创建：
var1 = 2
var2 = 35
print(var1, var2)
# 使用del语句可以删除对象的引用
del var1, var2

数值运算

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)  # 乘方

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)

# 与字符串不同，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)

# 逆向读取或逆向反转
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)

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,)  # 一个元素，需要在元素后添加逗号

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 中不同时存在的元素

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())  # 输出所有值

# 构造函数 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)

注释

• python中有单行注释和多行注释
• 单行注释使用 # 来实现
• 多行注释使用 ‘’’ 或 “”" 来实现

# 这是一个单行注释
print("Hello Python")

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

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

运算符

算术运算符

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

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)

赋值运算符

也是大同小异

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)

位运算符

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)

逻辑运算符

也是大同小异，看代码吧

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")

成员运算符

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

# 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 中")

身份运算符

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 有相同的标识")

数字(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)

数字运算

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

字符串

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

var1 = "Hello"
var2 = "Python"

访问字符串中的值

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

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

字符串更新

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

字符串运算符

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')

字符串格式化

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

转义字符

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

三引号

str1 = """三引号可以允许
一个字符串跨越多行，
还可以包括制表符(\t)
以及换行符(\n)
"""
print(str1)

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

列表

• 列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
• 列表的数据项不需要具有相同的类型
• 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

访问列表中的值

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

反向索引

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

对列表进行截取

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])

更新列表

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

list2 = ['Doinb', 'Lwx', 'Crisp']
list2.append('Tian')
print(list2)

删除列表

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

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

列表脚本操作符

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

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=" ")

列表截取与拼接

list1 = ['Chicken', 'Beef', 'Pork']
list2 = list1[0:2]
print(list2)
list1 += ['Apple', 'StrawBerry']
print(list1)

嵌套列表

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

元组

• Python 的元组与列表类似，不同之处在于元组的元素不能修改。
• 元组使用小括号 ( )，列表使用方括号 [ ]。
• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   #  不需要括号也可以
print(type(tup3))

# 创建空元组
tup1 = ()

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

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

tup1 = (50,)
print(type(tup1))  # 加上逗号，类型为元组

访问元组

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])

修改元组

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

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

# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)

删除元组

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

print(tup)
del tup
print("删除后的元组 tup : ")
print(tup)

字典

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

dict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

访问字典里的值

# 把相应的键放入到方括号中，如下实例:
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'])

修改字典

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

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

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

删除字典元素

# 能删单一的元素也能清空字典，清空只需一项操作。
# 显示删除一个字典用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'])

字典键的特性

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

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

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

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

集合

• 集合（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的元素

# 推导式，同样集合支持集合推导式(Set comprehension):
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)

集合的基本操作

添加元素

# 1、添加元素
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset)

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

删除元素

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

# thisset.remove("Facebook")  # 不存在会发生错误
# 此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook")  # 不存在不会发生错误
print(thisset)

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

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

print(x)

计算集合的元素个数

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

清空元素

# 清空集合
thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset)

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

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

条件控制

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")

循环语句

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))

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

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

print("Good bye!")

while循环使用else语句

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

for循环

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

使用break语句可跳出循环

# 使用break语句，可以跳出当前循环
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

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)

break语句

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

continue语句

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

pass语句

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

# Python pass是空语句，是为了保持程序结构的完整性。
while True:
    pass

迭代器和生成器

迭代器

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

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
print(next(it))  # 输出迭代器的下一个元素
print(next(it))

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

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

也可以使用next()函数

import sys  # 引入 sys 模块

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

while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

创建一个迭代器，把一个类作为一个迭代器使用需要在类中实现两个方法 __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))

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)

生成器

• 生成器，在 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()

函数

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

定义一个函数

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

def max(a, b):
    if a > b:
        return a
    else:
        return b


a = 4
b = 5
print(max(a, b))

# 计算面积函数
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))

# 定义函数
def printme(str):
    # 打印任何传入的字符串
    print(str)
    return
    
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

参数传递

可更改(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)

传可变对象实例

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


# 调用changeme函数
mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)

参数

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

必须参数

• 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
• 调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

def printme(str):
    """打印任何传入的字符串"""
    print(str)
    return


# 调用 printme 函数，不加参数会报错
printme()

关键字参数

• 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
• 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def printinfo(name, age):
    """打印任何传入的字符串"""
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(age=18, name="JQJQ")

默认参数

• 调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

不定长参数

• 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名
• 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    print(vartuple)


# 调用printinfo 函数
printinfo(70, 60, 50)

# 不指定变长参数，则它就是一个空元组
def printinfo(arg1, *vartuple):
    """打印任何传入的参数"""
    print("输出: ")
    print(arg1)
    for var in vartuple:
        print(var)
    return
    
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

# 加了两个星号 ** 的参数会以字典的形式导入。
def printinfo(arg1, **vardict):
    """打印任何传入的参数"""
    print("输出: ")
    print(arg1)
    print(vardict)

# 调用printinfo 函数
printinfo(1, a=2,b=3)

# 声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 * 后的参数必须用关键字传入。
def f(a, b, *, c):
    return a + b + c


# f(1,2,3)   # 报错
f(1, 2, c=3)  # 正常

return 语句

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


# 调用sum函数
total = sum(10, 20)
print("函数外 : ", total)

错误和异常

菜鸟教程错误和异常章节

面向对象

面向对象技术简介

• 类(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())

类的方法

在类的内部，使用 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()

继承

• 子类（派生类 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()

多继承

• 需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，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()   #方法名同，默认调用的是在括号中排前地父类的方法

方法重写

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

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


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


c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法
super(Child, c).myMethod()  # 用子类对象调用父类已被覆盖的方法

类属性与方法

类的私有属性

• __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)  # 报错，实例不能访问私有变量

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()      # 报错

类的专有方法

• 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)