python入门

python

开发环境搭建

python解析器安装

existing

点击TERMINAL 输入 PIP INSTALL LXML 自动安装东西

在project:xxxxx下面的python interpreter 可以看到安装的包

有严格的缩进关系 不能随便缩进 一个语句占一行

特色：用缩进来表示代码块，不需要使用大括号{} 缩进的空格数是可变的但是同一个代码块的语句必须使用相同的空格数

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 ** 来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

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

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

数字类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

int整数

boll 布尔 true false

float浮点数 1.23

complex(复数) 1+2j、1.1+2.2j

字符串（String）

Python3 find()方法

Python3 字符串

---

描述

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。

语法

find()方法语法：

str.find(str, beg=0, end=len(string))

参数

• str – 指定检索的字符串
• beg – 开始索引，默认为0。
• end – 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则返回-1。

实例

以下实例展示了find()方法的实例：

str1 = "Runoob example....wow!!!"

str2 = "exam";  

print (str1.find(str2))

print (str1.find(str2, 5)) 

print (str1.find(str2, 10))

#以上实例输出结果如下：
7
7
-1

实例

>>>info = ‘abca’ >>> print(info.find(‘a’)) # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0 0 >>> print(info.find(‘a’, 1)) # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3 3 >>> print(info.find(‘3’)) # 查找不到返回-1 -1 >>>

replace方法

str="kanc; l and faefq"
new=str.replace("and","aa")
print(new)
#原字符串没有改变

Python3 rfind()方法

Python3 字符串

---

描述

Python rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

语法

rfind()方法语法：

str.rfind(str, beg=0 end=len(string))

参数

• str – 查找的字符串
• beg – 开始查找的位置，默认为0
• end – 结束查找位置，默认为字符串的长度。

返回值

返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

实例

以下实例展示了rfind()函数的使用方法：

#!/usr/bin/python3

str1 = “this is really a string example…wow!!!”
str2 = “is”

print (str1.rfind(str2))

print (str1.rfind(str2, 0, 10))
print (str1.rfind(str2, 10, 0))

print (str1.find(str2))
print (str1.find(str2, 0, 10))
print (str1.find(str2, 10, 0))

以上实例输出结果如下：

5
5
-1
2
2
-1

单引号‘ 和双引号"" 使用完全相同

三引号’‘’ 或 “”" 可以指定一个多行字符串

转义符\

\n换行

反斜杠可以用来转义，使用r可以让反斜杠不发生转义 如r "xdxx \n"则 \n会显示而不是换行

按字面意义级联字符串 如“this”“is”"string"会被转换为this is string。

字符串可以用+运算符连接在一起 用*运算符重复

• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

• Python 中的字符串不能改变。

• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

• 字符输出的拼接：print(“width=”, w, " height =“, h, " area =”, area(w, h))

str='123456789'
print(str)#输出字符串
print(str[0:-1])#输出第一个到倒数第二个
print(str[0])#输出第一个
print(str[2:3])#输出第三道第四个数
print(str[2:])#输出第二个之后的数
print(str[1:5:2])#输出第二个到第五个且步长为2的数
print(str*5)
print(str+"你好啊")
print('hello\nrunoob')#\n表示换行 特殊转义符
print(R'hello\nrunoob')#加上r让他们无效

这里的 r 指 raw，即 raw string，会自动将反斜杠转义，例如：

>>> print('\n')       # 输出空行

>>> print(r'\n')      # 输出 \n
\n

input("\n\n按下 enter 键后退出。")

以上代码中 ，\n\n 在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

import sys;x='round';sys.stdout.write(x+"\n")

str.capitalize()第一个字母转大写，剩下转小写

str.lower()将字符串中大写转小写

str.upper()全转大写

lstrip()删左边

rstrip()删右边

strip()删两边

isdigit()只包含数字就返回true

isalpha()

isalnum()都是字母或数字组成返回true

多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之为代码组。像if,while,del和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句(clause)。

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

print输出是自动换行的如果想不换行 需要在变量末尾加上end=‘ ’

x='a';y='b'
#换行输出
print(x)
print(y)
#不换行输出
print(x,end='')
print(y,end='')

mport 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

python sys 模块

sys ==system,该模块提供了一些借口用于访问python解释器自身使用和维护的变量，同时模块中还提供了一部分函数，可以与解释器进行比较深度的交互。

常用功能

sys.argv

argv 即argument value的简写，是一个列表对象，其中存储的是在命令行调用python脚本时提供的‘命令行参数’。

这个列表中的第一个参数是被调用的脚本名称，也就是说，调用python解释器的‘命令’本身并没有被加入这个列表当中。

基本数据类型（2）

变量不需要声明，但是必须要赋值

counter=100 #整型变量
miles=1000.0#浮点型变量
name="runoob"#字符串

为多个变量赋值

a=b=c=1 多个对象指定多个变量 a,b,c=1,2,‘runoob’

六个标准数据类型：Number（数字）String（字符串）list（列表）Tuple(元组) Set(集合)Dictionary(字典)

不可变数据 （number ，string ，tuple）

可变（list ,dictionary ,set）

a, b, c, d=20,5.5,True,4+3j
print(type(a),type(b),type(c),type(d))
结果
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
a=111
isinstance(a,int)
输出true#判断数据类型

isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True1、False0 会返回 True*，但可以通过* is来判断类型。

您也可以使用del语句删除一些对象引用。没删之前都能调用

del car1,car2

del var_a,var_b

/返回一个浮点数 //返回一个整数

print(h/2)
print(h//2)
55.5
55

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B4CMXkg7-1655796244762)(\截图放置\123456-20200923-1.svg)]

不让反斜杠发生转义 可以在前面加一个r \n换行

Python 字符串不能被改变

Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

print("_".join(List1))

print("**".joni(tuple1))
#拼接
name="abcde"
print(name.join("-"))
print(len(list1),len(ti),len(name))

List（列表）

list是python中使用最频繁的数据类型 列表写在【】之间 用逗号隔开元素

可以索引和截取 列表被截取后返回一个包含所需元素的新列表

变量[头下标:尾下标]

索引值以0为开始值，-1为末尾开始位置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wBkXrOLS-1655796244763)(截图放置\list_slicing1_new1.png)]

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

与字符串不同列表里面的元素可以改变

list内置方法

方法	描述
list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于a[:]。

sort()排序要求列表中无int str两种类型同时存在

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

实例

\>>> stack = [3, 4, 5]
\>>> stack.append(6)
\>>> stack.append(7)
\>>> stack
[3, 4, 5, 6, 7]
\>>> stack.pop()
7
\>>> stack
[3, 4, 5, 6]
\>>> stack.pop()
6
\>>> stack.pop()
5
\>>> stack
[3, 4]

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

print(list[1:5:2])#输出两个元素 

Tuple(元组)

元组与列表类似，不同之处在于元组的元素不能修改。元组写在小括号（）里,元素之间用逗号隔开。元组中的元素类型也可以不相同

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

Set(集合)

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

parame = {value01,value02,...}或者set(value)

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

**print**(sites)  # 输出集合，重复的元素被自动去掉

\# 成员测试
**if** 'Runoob' **in** sites :
  **print**('Runoob 在集合中')
**else** :
  **print**('Runoob 不在集合中')


\# 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 中不同时存在的元素
#为空就是set()
比如a包含于b a-b为set()

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

del 语句和 pop() 函数作用相同，pop() 函数有返回值。

添加数据 dict[xx].append(xxx)

dict.popitem()

Python 字典 popitem() 方法返回并删除字典中的最后一对键和值。

如果字典已经为空，却调用了此方法，就报出 KeyError 异常。

语法

popitem()方法语法：

popitem()

参数

• 无

返回值

返回一个键值对(key,value)形式。

实例

以下实例展示了 popitem() 方法的使用方法：

\#!/usr/bin/python
\# -*- coding: UTF-8 -*-

site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
**print**(pop_obj)
**print**(site)

输出结果为：

('url', 'www.runoob.com')
{'alexa': 10000, 'name': '\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'}

实例

\#!/usr/bin/python3

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]   = "2 - 菜鸟工具"

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


print(dict['one'])    # 输出键为 'one' 的值
print(dict[2])      # 输出键为 2 的值
print(tinydict)      # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values()) # 输出所有值

以上实例输出结果：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

实例

>>> dict([(‘Runoob’, 1), (‘Google’, 2), (‘Taobao’, 3)])
{‘Runoob’: 1, ‘Google’: 2, ‘Taobao’: 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{‘Runoob’: 1, ‘Google’: 2, ‘Taobao’: 3}

*{x: x*2 for x in (2, 4, 6)} 该代码使用的是字典推导式，更多推导式内容可以参考：Python 推导式。

另外，字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。

注意：

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

python数据类型转换

函数	描述
[int(x ,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
[complex(real ,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

小精度加高精度 会小转大

我们再看一个实例，整型数据与字符串类型的数据进行相加：

实例

num_int = 123
num_str = “456”

print(“Data type of num_int:”,type(num_int))
print(“Data type of num_str:”,type(num_str))

print(num_int+num_str)

以上实例输出结果为：

num_int 数据类型为: <class 'int'>
num_str 数据类型为: <class 'str'>
Traceback (most recent call last):
  File "/runoob-test/test.py", line 7, in <module>
    print(num_int+num_str)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

从输出中可以看出，整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。

但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。

int()强转为则整形：

x = int(1) # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int(“3”) # z 输出结果为 3

float()强制转换为浮点型

x = float(1) # x 输出结果为 1.0
y = float(2.8) # y 输出结果为 2.8
z = float(“3”) # z 输出结果为 3.0
w = float(“4.2”) # w 输出结果为 4.2

round(xxx,2)#保留两位小数

str()强制转换为字符串类型

x = str(“s1”) # x 输出结果为 ‘s1’
y = str(2) # y 输出结果为 ‘2’
z = str(3.0) # z 输出结果为 ‘3.0’

Python推导式

python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。python支持各种数据结构的推导式；

列表(list)推导式

[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

names=['bob','ddd','dddd','sadfarfe']
new_names=[name.upper()for name in names if len(name)>3]
print(new_names)
mutt=[i for i in range(30) if i%3==0]
print(mutt)

range()函数

1、函数原型：range（start， end， scan)：
参数含义：
start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;
end:技术到end结束，但不包括end.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
scan：每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
2、python中的range()函数的功能很强大，所以我觉得很有必要和大家分享一下，就好像其API中所描述的：

字典(dict)推导式

{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }

listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}
提供三个数字，以三个数字为键，三个数字的平方为值来创建字典
for循环
>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

集合(set)推导式

{expression for item in Sequence}
或
{expression for item in Sequence if conditional}

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

元组(tuple)推导式

(expression for item in Sequence)
或
(expression for item in Sequence if conditional)

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

lambda表达式

students = [ {‘name’: ‘TOM’, ‘age’: 20},

{‘name’: ‘ROSE’, ‘age’: 19},

{‘name’: ‘Jack’, ‘age’: 22} ] # 按name值升序排列 students.sort(key=lambda x: x[‘name’]) print(students) # 按name值降序排列 students.sort(key=lambda x: x[‘name’], reverse=True) print(students) # 按age值升序排列 students.sort(key=lambda x: x[‘age’]) print(students)

python算术运算符

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为10的21次方
//	取整除 - 向下取接近商的整数	>>> 9//2 4 >>> -9//2 -5

Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。	在这个示例中，赋值表达式可以避免调用 len() 两次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")

c*=a-x;等效于c乘(a-x)

%(name,age)

end 结束符 sep分隔符

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

优先级顺序为 NOT、AND、OR。

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

and 返后 or 返前

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

id()函数用于获取对象内存地址

is与==的区别：is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，求余数和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 ‘AND’
^ |	位运算符
<= < > >=	比较运算符
== !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

and 有最高优先级 python已不支持<>运算符，可以用!=代替，如果你一定要使用这种比较运算符，可以使用以下的方式：

from __future__ import barry_as_FLUFL
>>> 1 <> 2
True

f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 (%):

实例

>>> name = ‘Runoob’
>>> ‘Hello %s’ % name
‘Hello Runoob’

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

实例

>>> name = ‘Runoob’
>>> f’Hello {name}’ # 替换变量
‘Hello Runoob’
>>> f’{1+2}’ # 使用表达式
‘3’

>>> w = {‘name’: ‘Runoob’, ‘url’: ‘www.runoob.com’}
>>> f’{w[“name”]}: {w[“url”]}’
‘Runoob: www.runoob.com’

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。

if语句

if condition_1:
	statement_block_1
elif condition_2:
	statement_block_1
else:
	statement_block_3

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

• 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在Python中没有switch – case语句。

以下为if中常用的操作运算符:

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等

三元运算符

值1 if 条件 else 值2

print("1".center(20))
print(format("121","^20"))#居中
print('1'.rjust(20,"#"))#居右对齐加*号
print(format("121","<20"))#左对齐

常见的移动命令：

命令

说明

turtle.forward(distance)#向当前画笔方向移动distance像素长度

turtle.backward(distance)#向当前画笔相反方向移动distance像素长度

turtle.right(degree)#顺时针转动degree°

turtle.left(degree)#逆时针转动degree°

turtle.pendown()#放下画笔，移动时绘制图形，默认为绘制

turtle.goto(x,y)#将画笔移动到坐标为x,y的位置

turtle.penup()#提起画笔，移动时不绘制图形，用于另起一个地方绘制

turtle.circle(radius, extent=None,step=None)#画圆，半径为正(负)，表示圆心在画笔的左边(右边)画圆

setx( )#将当前x轴移动到指定位置

sety( )#将当前y轴移动到指定位置

setheading(angle)/seth(angle)#设置当前朝向为angle角度

home()#设置当前画笔位置为原点，朝向东。

dot®#绘制一个指定直径和颜色的圆点

distance为传入的数值，代表移动的长度。

degree为传入的数值，代表转动的角度。

angle为传入的数值，以右边（东边）为0。当设置为0时朝向右边（东边），设置为90时朝向北边（上边），以此类推。

常用颜色命令:

命令

说明

turtle.fillcolor(colorstring)

绘制图形的填充颜色

turtle.color(color1, color2)

同时设置pencolor=color1, fillcolor=color2

turtle.filling()

返回当前是否在填充状态

turtle.begin_fill()

准备开始填充图形

turtle.end_fill()

填充完成

turtle.hideturtle()

隐藏画笔的turtle形状

turtle.showturtle()

显示画笔的turtle形状

全局控制命令：

命令

说明

turtle.clear()

清空turtle窗口，但是turtle的位置和状态不会改变

turtle.reset()

清空窗口，重置turtle状态为起始状态

turtle.undo()

撤销上一个turtle动作

turtle.isvisible()

返回当前turtle是否可见

stamp()

复制当前图形

turtle.write(s [,font=(“font-name”,font_size,“font_type”)])

写文本，s为文本内容，font是字体的参数，分别为字体名称，大小和类型；font为可选项，font参数也是可选项

其他常用命令:

命令

说明

turtle.mainloop()或turtle.done()

启动事件循环 -调用Tkinter的mainloop函数。

必须是海龟图形程序中的最后一个语句。

turtle.mode(mode=None)

设置海龟模式（“standard”，“logo”或“world”）并执行重置。如果没有给出模式，则返回当前模式。

模式

初始海龟朝向

正角度

standard

向右（东）

逆时针

logo

向上（北）

顺时针

turtle.delay(delay=None)#设置或返回以毫秒为单位的绘图延迟。

turtle.begin_poly()#开始记录多边形的顶点。当前的海龟位置是多边形的第一个顶点。

turtle.end_poly()#停止记录多边形的顶点。当前的海龟位置是多边形的最后一个顶点。将与第一个顶点相连。

turtle.get_poly()#返回最后记录的多边形。

turtle.fd(a) #海龟向前移动a个单位
turtle.bk(b) #海龟向后移动b个单位

Python 异常处理

python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。

• 异常处理: 本站Python教程会具体介绍。
• 断言(Assertions):本站Python教程会具体介绍。

---

python标准异常

异常名称	描述
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError	Python 语法错误
IndentationError	缩进错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

---

异常处理

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：

以下为简单的try…except…else的语法：

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

• 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

• 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印默认的出错信息）。

• 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

• #!/usr/bin/python
  # -- coding: UTF-8 --

  try:
  fh = open(“testfile”, “w”)
  fh.write(“这是一个测试文件，用于测试异常!!”)
  except IOError:
  print “Error: 没有找到文件或读取文件失败”
  else:
  print “内容写入文件成功”
  fh.close()

使用except而不带任何异常类型

try:
	print("123")
except:
	发生异常可执行代码
else:
	如果没有异常执行这块代码
    #try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。

使用except而带多种异常类型

try:
	print("123")
except(Exception1[,Exception2[,...ExceptionN]]):
	发生上面异常中的一个，执行这块代码
else:
	如果没有异常执行这块代码

try-finally语句

try:
	<语句>
finally：
	<语句>
raise
无论如何都会执行finally语句
实例：
try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"
    可以try-except里面夹 try-finally 执行finally后继续异常触发执行except块代码
#实例2
    print("程序开始")
try:
    a=1/0
    c=b*10
    my_list=[1,2,3]
except ZeroDivisionError:
    print("出现零整除异常")
except NameError as e:
    print("处理名称异常")
    print(e)
except Exception as e:
    print(e)
    print("大包大揽异常")
else:
    print("try中没有异常")
finally:
    print("异常模块最后的代码，无论有无异常")
print("程序后续代码")

异常的参数

一个异常可以带上参数，可作为输出的异常信息参数。你可以通过except语句来捕获异常的参数

try:
	xxxx
except exceptionTyoe as Argument:
	print(Argument)
#实例
a="hhh"
try:
    print(int(a))
except ValueError as Argument:
    print("dd",Argument)

dd=1
if dd<1:
    print("123")#代码不会运行 不会输出123
    raise Exception("Invalid dd!",dd)
print("1211")#此处正常运行

捕获异常

def mye( level ):
    if level < 1:
        raise (Exception,"Invalid level!")
        # 触发异常后，后面的代码就不会再执行
try:
    mye(0)            # 触发异常
except Exception as err:#自定义异常
    print(1,err)
else:
    print(2)

可以由调用者来处理程序中的异常

异常嵌套

异常出现后如果没有被捕获处理，该异常将会像上一级传递，假如都没有捕获，则中断程序，且抛出异常

print("程序开始。。。")
try:
    try:
        print(1/0)
    except NameError as e:
        print("名称不存在异常"+e)
except ZeroDivisionError:
    print("零整除异常...")
print("程序后续代码")

函数方法嵌套

print("程序开始")
def oper1():
	print(1/0)
def oper2():
	try:
		oper1()
	except Exception as e:
		print("oper2调用者",e)
oper2()
print("程序后续代码")

用户自定义异常（有待补充）

---

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

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

列表（Lists）：

这些可能是最明显的迭代。

for x in [None,3,4.5,"foo",lambda : "moo",object,object()]:
    print "{0}  ({1})".format(x,type(x))

输出结果为：

None  (<type 'NoneType'>)
3  (<type 'int'>)
4.5  (<type 'float'>)
foo  (<type 'str'>)
<function <lambda> at 0x7feec7fa7578>  (<type 'function'>)
<type 'object'>  (<type 'type'>)
<object object at 0x7feec7fcc090>  (<type 'object'>)

元组（Tuples）：

元组在某些基本方面与列表不同，注意到以下示例中的可迭代对象使用圆括号而不是方括号，但输出与上面列表示例的输出相同。

for x in (None,3,4.5,"foo",lambda : "moo",object,object()):
    print "{0}  ({1})".format(x,type(x))

输出结果为：

None  (<type 'NoneType'>)
3  (<type 'int'>)
4.5  (<type 'float'>)
foo  (<type 'str'>)
<function <lambda> at 0x7feec7fa7578>  (<type 'function'>)
<type 'object'>  (<type 'type'>)
<object object at 0x7feec7fcc090>  (<type 'object'>)

字典（Dictionaries）：

字典是键值对的无序列表。当您使用for循环遍历字典时，您的虚拟变量将使用各种键填充。

d = {
  'apples' : 'tasty',
  'bananas' : 'the best',
  'brussel sprouts' : 'evil',
  'cauliflower' : 'pretty good'
}

for sKey in d:
  print "{0} are {1}".format(sKey,d[sKey])

输出结果为：

brussel sprouts are evil
apples are tasty
cauliflower are pretty good
bananas are the best

也许不是这个顺序，字典是无序的！！！

遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> **for** k, v **in** knights.items():
...   **print**(k, v)
...
gallahad the pure
robin the brave

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate([‘tic’, ‘tac’, ‘toe’]):
… print(i, v)
…
0 tic
1 tac
2 toe

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = [‘name’, ‘quest’, ‘favorite color’]
>>> answers = [‘lancelot’, ‘the holy grail’, ‘blue’]
>>> for q, a in zip(questions, answers):
… print(‘What is your {0}? It is {1}.’.format(q, a))
…
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.

要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

>>> for i in reversed(range(1, 10, 2)):
… print(i)
…
9
7
5
3
1

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

会将重复值去掉

>>> basket = [‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’]
>>> for f in sorted(set(basket)):
… print(f)
…
apple
banana
orange
pear

python3 函数

定义一个函数

函数代码块以def关键词开头，后接函数标识符名称和圆括号()。

任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

函数的第一行语句可以选择性使用文档字符串一用于存放函数说明。

函数内容以冒号:起始，并且缩进。

return[表达式]结束函数，选择性地返回一个值给调用方，不带表达式的return相当于返回None。

返回值可以有多个，但是归根结底是返回一个元组（xxx,xxx）

语法

Python定义函数使用def关键字，一般格式如下：

def 函数名(参数列表):
	函数体

参数传递

global 可以在方法体内声明为全局变量；

num=1
def fun():
	global num
	print(num)
	num=123
	print(num)
fun()
print(num)

修改作用域的中的变量则需要nonlocal关键字

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的：

a=[1,2,3]

a="Runoob"

以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

缺省参数

缺省参数也叫默认参数，用于定义参数，为形参提供默认值，调用函数时可不传该默认参数值

默认参数是形参，必须写在位置参数的后面

调用函数时，可以不传参给默认参数，不传参则用默认值

可更改(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 传不可变对象实例

通过 id() 函数来查看内存地址变化：

实例(Python 3.0+)

def change(a): print(id(a)) # 指向的是同一个对象 a=10 print(id(a)) # 一个新对象 a=1 print(id(a)) change(a)

以上实例输出结果为：

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
>>>
print(id(a))
change(a)
4379369136
4379369136
4379369424

可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

传可变对象实例

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

实例(Python 3.0+)

#!/usr/bin/python3 

  可写函数说明

 def changeme( mylist ):   

"修改传入的列表"   

mylist.append([1,2,3,4])  

 print ("函数内取值: ", mylist)

   return  

#调用changeme函数 

mylist = [10,20,30]

 changeme( mylist )

 print ("函数外取值: ", mylist)

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

不定长参数

尽量和缺省参数等分开写

不然容易语法错误

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]
加*的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def printinfo(arg1,*vartuple):
    print("输出")
    print(arg1)
    print(vartuple)
printinfo(70,60,50)

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

实例

\#!/usr/bin/python3
# 可写函数说明
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(arg1)
	print(vardict)
printinfo(1,a=2,c=5)
#输出 1 {“a”=2,'c'=5}

#如果单独出现星号 * 后的参数必须用关键字传入。
def dd(a,b,*,c):
    print(type(c))
    return a+b+c
dd(1,2,c=3)
通过print(dd(1,2,c=3))可以获得return值

匿名参数

python使用lambda来创建匿名函数，匿名指不再使用def语句这样标准的形式定义一个函数。

lambda只是一个表达式，较简单

主题是表达式不是一个代码块，仅仅在lambda表达式中封装有限的逻辑进去。

函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数

语法

lambda [arg1[,arg2,....argn]]:expression
x=lambda a:a+10
print(x(5))
--------------------------------
def runing(j):
    return lambda a:a-j
mm=runing(2)
print(mm(5))
#调用方法赋值给j 然后赋值给a
>>>3
强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)
以下使用方法会发生错误:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

import module1[, module2[,... moduleN]

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：

support.py 文件代码

#!/usr/bin/python3 
#Filename: support.py  
def print_func( par ):
print ("Hello : ", par)
return
test.py 引入 support 模块：

test.py 文件代码

#!/usr/bin/python3
# Filename: test.py
# 导入模块 import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

一个模块只会被导入一次

如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：

>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 fibo 的 fib 函数，使用如下语句：(只导入了函数)

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。

---

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

导包注意事项

注意当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。

import 语法会首先把 item 当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，抛出一个 :exc:ImportError 异常。

反之，如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

输入和输出

str()返回一个用户易读的表达形式 repr() 产生一个解释器易读的表达形式

repr() 函数可以转义字符串中的特殊字符 让特殊字符如：\n能正常输出

repr() 的参数可以是 Python 的任何对象

字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。

另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：

#后面括号里的数表示至少输出多少位数字 不足补零 小数点和负号有占位
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

这里面：{0:2d} 表示第一个参数x的格式。0 代表x,:2d 表示两个宽度的10进制数显示。

          {1:3d} 表示第一个参数x*x的格式。1 代表x*x,:3d 表示三个宽度的10进制数显示。
          {2:4d} 表示第一个参数x*x*x的格式。2代表x*x*x,:4d 表示四个宽度的10进制数显示。

str.format() 的基本使用如下:

>>> print(‘{}网址： “{}!”’.format(‘菜鸟教程’, ‘www.runoob.com’))
菜鸟教程网址： “www.runoob.com!”

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

>>> print(‘{0} 和 {1}’.format(‘Google’, ‘Runoob’))
Google 和 Runoob
>>> print(‘{1} 和 {0}’.format(‘Google’, ‘Runoob’))
Runoob 和 Google

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

>>> print(‘{name}网址： {site}’.format(name=‘菜鸟教程’, site=‘www.runoob.com’))
菜鸟教程网址： www.runoob.com

位置及关键字参数可以任意的结合:

>>> print(‘站点列表 {0}, {1}, 和 {other}。’.format(‘Google’, ‘Runoob’, other=‘Taobao’))
站点列表 Google, Runoob, 和 Taobao。

!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化:

>>> import math
>>> print(‘常量 PI 的值近似为： {}。’.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print(‘常量 PI 的值近似为： {!r}。’.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。

可选项：和格式标识符可以跟着字段名。这样可以更好的格式化

import math
print("pi的值近似为：{0:.3f}。".format(math.pi))

在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
	for  name, number in table.items():
	print('{0:10} ==> {1:10d}'.format(name, number))
Google   ==>      1
Runoob   ==>      2
Taobao   ==>      3
#理解：第一个元素的[key值]
#也可以通过在 table 变量前使用 ** 来实现相同的功能：

>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3

旧式字符串格式化

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

>>> import math
>>> print(‘常量 PI 的值近似为：%5.3f。’ % math.pi)
常量 PI 的值近似为：3.142。

因为 str.format() 是比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode,encoding)

• filename：包含了你要访问的文件名称的字符串值。
• mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
• 设置编码方式，涉及到中文一般设置encoding=“UTF-8”

不同模式打开文件的完全列表：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

https://www.runoob.com/wp-content/uploads/2013/11/2112205-861c05b2bdbc9c28.png

file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

序号	方法及描述
1	file.close()关闭文件。关闭后文件不能再进行读写操作。
2	file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next()**Python 3 中的 File 对象不支持 next() 方法。**返回文件下一行。
6	[file.read(size])从文件读取指定的字节数，如果未给定或为负则读取所有。
7	[file.readline(size])读取整行，包括 “\n” 字符。
8	[file.readlines(sizeint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	[file.seek(offset, whence])移动文件读取指针到指定位置
10	file.tell()返回文件当前位置。
11	[file.truncate(size])从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12	file.write(str)将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

以下实例将字符串写入到文件 foo.txt 中：

实例

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")
地址可以写绝对路径
f.write( "Python 是一个非常好的语言。**\n**是的，的确非常好!!**\n**" )
# 关闭打开的文件
f.close()
W=open("/tt/foo.txt","r")
a=f.read()
print(a)
f.close()
##
Python 是一个非常好的语言。
是的，的确非常好!!

• 第一个参数为要打开的文件名。
• 第二个参数描述文件如何使用的字符。 mode 可以是 ‘r’ 如果文件只读, ‘w’ 只用于写 (如果存在同名文件则将被删除), 和 ‘a’ 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. ‘r+’ 同时用于读写。 mode 参数是可选的; ‘r’ 将是默认值。

此时打开文件 foo.txt,显示如下：

$ cat /tmp/foo.txt 
Python 是一个非常好的语言。
是的，的确非常好!!

f.readline()

f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

实例

\# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str)
\# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
Python 是一个非常好的语言。

概述

readline() 方法用于从文件读取整行，包括 “\n” 字符。可以添加size-(从文件中读取的字节数)如果指定了一个非负数的参数，则返回指定大小的字节数，包括 “\n” 字符。

用一次读一行 重复使用就一直往下读取

f.readlines()

f.readlines() 将返回该文件中包含的所有行。

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

参数没搞明白 后续有待补充；

write(“str”)

不是str需要转换才能添加

f.tell()

f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

f.seek()

如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

• seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x,1) ： 表示从当前位置往后移动x个字符
• seek(-x,2)：表示从文件的结尾往前移动x个字符
• 读取位置发生改变 文件内容不变

得二进制读取文件
\>>> f = open('/tmp/foo.txt', 'rb+')
\>>> f.write(b'0123456789abcdef')
16
\>>> f.seek(5)   # 移动到文件的第六个字节
5
\>>> f.read(1)
b'5'
\>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
\>>> f.read(1)
b'd'

f.close()

在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

with open("/foo.txt","r") as f:
	read_date=f.read()

当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:

\>>> **with** open('/tmp/foo.txt', 'r') **as** f:
...   read_data = f.read()
\>>> f.closed
True

文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。

二进制文件的操作方式

二进制文件,也称非文本文件 ，比如图片、音乐、视频、软件等 语法：

open(name,‘wb’|‘rb’|‘ab’) 注意：

使用wb,rb,ab 访问模式 同时支持文本文件、二进制文件的访问，

针对于图片、声音、视频等二进制文件则必须使用该模式 使用w,r,a访问模式

只支持文本文件的访问

文件和文件夹的管理：

在Python中文件和文件夹的操作要借助os模块里面的相关功能

#import os导入模块： 工具箱
重命名文件或文件夹： os.rename("原文件名"，"新文件名")
os.rename("text.txt","aaa.txt")
删除文件: os.remove(目标文件名)
os.remove("aaa.txt")
创建文件夹： os.mkdir("文件夹名字")
os.mkdir("aaa")
删除文件夹： os.rmdir("文件夹名字")
os.rmdir("aaa")
获取当前目录： os.getcwd()
print(os.getcwd())
C:\Users\PZ_EDU\PycharmProjects\pythonProject2
改变目录：os.chdir(目录)
列举目录内容： os.listdir(目录)

实例

"""
1. 导入模块os
2. 使用模块内功能
"""
import os
# 1. rename(): 重命名
# os.rename('1.txt', '10.txt')
# 2. remove(): 删除文件
# os.remove('10.txt')
# 3. mkdir()：创建文件夹
# os.mkdir('aa')
# 4.rmdir(): 删除文件夹
# os.rmdir('aa')
# 5. getcwd(): 返回当前文件所在目录路径
# print(os.getcwd())
# 6. chdir():改变目录路径
# os.mkdir('aa')
# 需求：在aa里面创建bb文件夹: 1. 切换目录到aa，2创建bb
# os.mkdir('bb')
# os.chdir('aa')
os.mkdir('aa\\bb')
# 7. listdir(): 获取某个文件夹下所有文件，返回一个列表
# print(os.listdir())
# print(os.listdir('aa'))

文件综合应用

需求：用户输入当前目录下任意文件名，程序完成对该文件的备份功能(备份文件名为xx[备份].后缀，例 如：test.txt—>test[备份].txt)。

步骤

1. 接收用户输入的文件名
2. 规划备份文件名
3. 备份文件写入数据

代码实现

接收用户输入目标用户名

old_name=input(“请输入你要备份的文件字”)

#提取文件后缀点的下标
index= old_name.rfind(".")
print(index)
print(old_name[:index])#源文件名（无后缀）

picket 模块

python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保护的对象。

基本接口：

pickle.dump(obj,file,[,protpcol])

x=pickle.load(file)

注解：从file中读取一个字符串，并将它重构为原来的python对象。

file:类文件对象，有read()和readline()接口。

实例：

import pickle
data1={"a":[1,2.0,3,4+6],"b":("string",u'Unicode string'),
       "c":None}
selfref_list=[1,2,3]
print(selfref_list)
selfref_list.append(selfref_list)
print(selfref_list)
output = open("data.pkl","wb")
pickle.dump(data1,output)
pickle.dump(selfref_list,output,-1)
output.close()

没搞懂 后期补充

Python map() 函数

map(function, iterable, ...)

参数

• function – 函数
• iterable – 一个或多个序列

>>> def square(x) :         # 计算平方数
...     return x ** 2
...
>>> map(square, [1,2,3,4,5])    # 计算列表各个元素的平方
<map object at 0x100d3d550>     # 返回迭代器
>>> list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

写入网站代码

from urllib import request

response = request.urlopen("http://www.baidu.com/")  # 打开网站
fi = open("project.txt", 'w')                        # open一个txt文件
page = fi.write(str(response.read()))                # 网站代码写入
fi.close()                                           # 关闭txt文件

七、面向对象

7.1 面向对象基础

目标

理解面向对象编程思想

类和对象

添加和访问对象属性，添加和访问对象的方法

魔法方法、魔术方法

理解面向对象

面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想

两种编程思想比对

1. 面向过程编程思想 ： 关注的是实现步骤 : 班级考勤功能 ：
2. 准备好考勤表，2.一个一个点名 3. 4.提交
3. 面向对象编程(oop)思想 ：委托班长来考勤 关注的是由谁来做，由谁完成
4. 区别： 面向对象编程(Object Oriented Programming)更适合复杂的项目开发，更贴近现实世界（万物皆 对象）

类和对象

在面向对象编程过程中，有两个重要组成部分：类 和 对象

类

类是对一系列具有相同特征和行为的事务的统称，是一个抽象的概念，不是真实存在的事物，比如 客服、学生、老师、鼠标、键盘等

特征即是属性

行为即是方法

类 比如是制造洗衣机时要用到的图纸，也就是说类是用来创建对象

对象

对象是类创建出来的真是存在的事物，是实际存在的个体，日常生活看到的全是对象

类与对象

类是对象的模型，而对象是类的具体存在的形式

先有类再有对象，由类创建对象

一个类可以创建多个对象

定义类

class 类名():
	代码
	.......
class washer():
    def wash(self):
        print("我会洗衣服")
#创建对象
#对象名 = 类名()
#实例化对象
haier1 = washer()
#haier对象调用
haier1.wash()

类名要满足标识符命名规则还有驼峰命名习惯

添加和访问对象属性

属性即使特征，比如：洗衣机的宽度、高度、重量…

一般在定义类的–init–()方法中添加对象属性

self属性名

#定义类
class washer():
	def __inin__(self):
		'''初始化 对象'''
		self.width=600
		self.height=800
	def print_info(self):
		#类里面获取实例属性
		print("洗衣机的宽度是：{0}，长度是{1}".format(self.width,self.height))
    aa=washer()
    a.print_info()
    #结果
    #<__main__.washer object at 0x0000019B58A57FD0>
	#洗衣机的宽度是：600，长度是800

魔法方法(魔术方法)

在Python中， --xx–() 的方法叫做魔法方法，具有特殊的功能， 在特定场景中系统会自动调用，而 不需手动调用。

init() 方法的作用：初始化对象，一般在该方法中设置对象的属性等

带参数的 init()

思考：一个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢？

答：传参数。

str() 描述: 当使用print输出对象的时候，默认打印对象的内存地址。

如果类定义了 str 方法，那么就会 打印从在这个方法中 return 的数据。

使用场景: 使用字符串的形式描述对象的状态

# 类里面调用实例属性
print(f'洗衣机的宽度是{self.width}, 高度是{self.height}')
haier1 = Washer() 
haier1.print_info() 
class Washer(): 
	def __init__(self, width, height): 
		self.width = width
        self.height = height
        def print_info(self):
        print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的高度是{self.height}')
    haier1 = Washer(10, 20)
    haier1.print_info()
    haier2 = Washer(30, 40)
    haier2.print_info()

不同对象 即使同类 地址也不相同

–str–()

描述: 当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了 str 方法，那么就会 打印从在这个方法中 return 的数据。

    def __str__(self):
        return "洗衣机"

–del–()

删除对象时，系统会自动调用–del–()方法

一般用于删除对象前的清理工作，状态保存等工作

实操

class Furniture():
    def __init__(self,name,area):
        #家具名字
        self.name=name
        #家具占地面积
        self.area=area
class house():
    def __init__(self,localhost,S):
        self.localhost=localhost
        self.S=S
        self.freeS=S
        self.name=[]
    def __str__(self):
        return "家位于：{0},占地面积为：{1}，剩余面积为：{2}，屋内拥有家居：{3}".format(self.localhost,self.S,self.freeS,self.name)
    def surplus(self,item):
        if self.freeS>=item.area:
            self.name.append(item.name)
            self.freeS-=item.area
        else:
            print("家具太大，无法容纳")
jj1=Furniture("浴缸",150)
jj2=Furniture("浴缸",150)
jj3=Furniture("浴缸",150)
jia=house("北京",800)
jia.surplus(jj1)
jia.surplus(jj2)
jia.surplus(jj3)
jia.surplus(jj3)
print(jia)
#家具传参之后，可以再把‘家具’对象传给‘家’对象

面向对象（继承）

目标

• 继承的概念
• 单继承
• 多继承
• 子类重写父类的同名属性和方法
• 子类调用父类的同名属性和方法
• 多层继承 super()方法

单继承(子类只能继承一个父类)

# 父类A 
class A(object):
	def __init__(self):
    # A类中定义实例属性
    self.num = 1
    # A类中定义了一个方法 
    def info_print(self):
    print(self.num) 
# 子类B 
class B(A): 
	pass
b = B()
b.info_print() # 1

多继承

class Master(object):
    def __init__(self):
        self.kongfu="古法煎饼果子配方" #实例变量，属性
    def make_packet(self):
        print("【古法】按照<%s>制作了一分煎饼果子...." %self.kongfu)
    def yandai(self):
        print("师傅的大烟袋")
class School(object):
    def __init__(self):
        self.kongfu="现代煎饼配方"
    def make_cake(self):
        print("[现代]按照<%s>制作了一份煎饼果子"%self.kongfu)
    def xiaoyandai(self):
        print("学校特产：小烟袋")
class Prentice(School,Master):
    #先执行前面的父类
    def make_some(self):
        print(self.kongfu+"，非常好吃")
aa=Prentice()
#子类对象可以直接使用父类属性
#子类对象可以直接使用父类方法
#子类可以继承父类所有的属性和方法，
# 哪怕子类没有自己的方法和属性，也可以使用父类的属性和方法
aa.make_some()
aa.yandai()
aa.xiaoyandai()
#不重名不受影响
print(Prentice.__mro__)
#多继承就是一个类同时继承了多个父类
# 多继承可以继承多个父类，也继承了所有父类的属性和方法
# 如果多个父类有同名的属性或者方法
# 则默认使用第一个父类的属性和方法（可以根据类的魔法属性--mro--的顺序来查看）
# mro:方法解析顺序

子类调用父类的同名方法和属性

父类名.方法名(对象)：School.make_cake()

super(本类名，对象).方法名()：super(Prentice, self).make_cake()

super().方法名() #推荐方式

多层继承

class Master():
    def __init__(self):
        self.kongfu="[古法煎饼果子配方]"
    def make_packet(self):
        print("运用{}，制作煎饼果子".format(self.kongfu))
class Prentice(Master):
    def show(self):
        print("这是子类")
class Student(Prentice):
    def show(self):
        print("这是徒孙类{}".format(self.kongfu))
        super(Student, self).show()
    def test(self):
        super().make_packet()
student=Student();
student.make_packet()
student.show()
student.test()

父类可对属性和方法设置私有权限防止子类继承

父类的 私有属性 和 私有方法

私有权限

在属性名和方法名前面加上两个下划线_，即可设置为私有权限

# 父类A
class A(object):
	def __init__(self):
    # A类中定义实例属性
    self.__num = 1 
    # A类中定义了一个方法
    def info_print(self):
    	print(self.__num) 
# 子类B
# 子类无法直接调用私有属性
class B(A):
	pass 
b = B() 
b.info_print() # 1

1、子类对象 不能够在自己的方法内部，直接 访问 父类的 私有属性 或 私有方法；
2、子类对象 可以通过 父类 的公有方法 间接 访问到 私有属性 或 私有方法；

• 私有属性、方法 是对象的隐私，不对外公开，外界 以及 子类 都不能直接访问；
• 私有属性、方法 通常用于做一些内部的事情；
  
  • B 的对象不能直接访问 __num2 属性
  • B 的对象不能在 demo 方法内访问 __num2 属性
  • B 的对象可以在 demo 方法内，调用父类的 test 方法
  • 父类的 test 方法内部，能够访问 __num2 属性和 __test 方法

class A:

    def __init__(self):
        self.num1 = 100
        self.__num2 = 200

    def __test(self):
        print("私有方法 %d %d" % (self.num1, self.__num2))

    def test(self):
        print("私有方法 %d %d" % (self.num1, self.__num2))


class B(A):
    def demo(self):
        # 1. 在子类的对象方法中，不能访问父类的私有属性
        # print("访问父类的私有属性 %d" % self.__num2)

        # 2. 在子类的对象方法中，不能调用父类的私有方法
        # self.__test()
        pass
# 创建一个子类对象
b = B()
print(b)
b.test()
b.demo()
# 在外界不能直接访问对象的私有属性/调用私有方法
# print(b.__num2)
# b.__test()

面向对象(多态)

面向对象三大特性

封装

将属性和方法书写到类的里面的操作即为封装

可以为属性设置私有权限实现数据的封装

继承

子类默认继承父类的所有属性和方法

子类可以重写父类属性和方法

多态

同一操作传入不同的对象(不同对象有继承关系)，产生不同的结果

# 子类继承父类
# 子类重写父类方法
# 通过对象调用这个方法
class Docter:
    def cure(self):
        print("医生给出了治疗方案")
class Son(Docter):
    def cure(self):
        print("儿子给出了治疗方案")
class Daughtert(Docter):
    def cure(self):
        print("女儿给出了治疗方案")
def call_cure(doctor):
    doctor.cure()
son=Son()
call_cure(son)

多态的好处

提高了代码的维护性（继承保证）；提高了代码的扩展性。给call_cure(doctor)函数传递哪个对象,在它里面就会调用哪个对象的cure()方法,也就是说在它里面既可

以调用son对象的cure()方法,也能调用father对象的cure()方法,当然了也可以在它里面调用Father类其它

子类对象的cure()方法,这样可以让call_cure(doctor)函数变得更加灵活,额外增加了它的功能,提高了它的扩展性

类属性和实例属性

设置和访问类属性

类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有

类属性可以使用类对象或实例对象访问，建议用类名(类对象)来访问。

class Dog():
    tooth=10
aa=Dog()
bb=Dog()
print(Dog.tooth)
print(aa.tooth)
print(bb.tooth)
#结果
#10
#10
#10

类属性的优点

• 记录某项数据 始终保持一直时，则定义类属性

• 实例属性要求每个对象为其单独开辟一份存储空间来记录数据，而类属性为全类所共有，仅占用一份内存，更加节省内存空间，且维护更加方便。

class Dog(object): 
	tooth = 10 
wangcai = Dog()
xiaohei = Dog() 
# 修改类属性 
Dog.tooth = 12 
print(Dog.tooth) 
# 12 
print(wangcai.tooth) 
# 12 
print(xiaohei.tooth) 
# 12 
# 不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性 
wangcai.tooth = 20 
print(Dog.tooth) 
# 12 
print(wangcai.tooth) 
# 20 
print(xiaohei.tooth) 
# 12

不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性

class Dog():
    tooth= 10
    #类属性
    def __init__(self,color,name):
        self.color=color
        #实例属性
        self.name=name
    def __str__(self):
        #通过类名调用类属性
        return "My Dog name is {},it's a {} Dog,that have {} tooth".format(self.name,self.color,Dog.tooth)
wancai=Dog("黑色","旺财")
print(wancai)

类方法

需要使用装饰器@classmethod来标识器为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数，当方法中只需要使用类对象时，定义类方法

类方法一般和类属性配合使用

class Dog():
    tooch=10
    @classmethod
    def tooch_sum(cls):
        print(Dog.tooch)
        print(cls.tooch)
dog=Dog()
dog.tooch_sum()
Dog.tooch_sum()
#建议使用类名来访问类方法

类的专有方法：

都是两个下划线在两边

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

静态方法

装饰器@staticmethod来进行修饰

当方法中既不需要传递类对象 也不需要实例对象 可以用静态方法

静态方法可以调用类对象 不能调用实例对象

@staticmethod
def some_thing():
    print("this is my like dog！")
    print(Dog.tooch)

eval(“xxx”)

可以把里面的东西当做代码直接运行

print(eval(input("请输入要计算的公式")))

不要滥用eval

__import__('os').system("ls")

Python pass 语句

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

pass 不做任何事情，一般用做占位语句。

该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

• 注意，十进制数值不能以0开头的，否则就会报错。
• 只要是数字，打印时一定是以十进制的形式显示，此设置是为了能让python统一转换数字，防止系统会混淆进制的显示。

操作系统的接口

os模块提供了不少与操作系统相关联的函数

import os
#返回当前工作目录
os.getcwd()
#修改当前工作目录
os.chdir("/")
#执行系统命令 mkdir
os.system("mkidr today")

建议使用 “import os” 风格而非 “from os import *”。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。

在使用 os 这样的大型模块时内置的 dir() 和 help() 函数非常有用:

>>> import os
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>

针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')

import shutil
#拷贝
shutil.copy("test.py","test2.py")
#移动
shutil.move("test.py","installdir")

数据库连接

先导包

pip install pymysql

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eRkodstz-1655796244766)(F:\file\MarkText\text\截图放置\image-20220524102953113.png)]

• 使用pymysql模块创建Connection对象
• 通过Connection对象取得(创建)Cursor游标对象
• 通过Cursor游标对象执行sql语句
• 通过Cursor游标对象取得执行结果
• 处理执行结果\业务相关
• 关闭Cursor游标对象
• 关闭连接

通过python执行sql语句实现数据表增删改查

import pymysql
conn=pymysql.connect(user='root',password='baidu123',database='demodb',port=3306,charset='utf8')
cursor=conn.cursor()
sql="select * from tb_contact;"
cursor.execute(sql)
print(cursor.fetchall())
cursor.close()
conn.close()

包

描述：包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为_ini_.py文件，那么这个文件夹就称之为包；

自动加载–init–内部代码

制作包

[New] — [Python Package] — 输入包名 — [OK] — 新建功能模块(有联系的模块)。 注意：新建包后，包内部会自动创建 init.py 文件，这个文件控制着包的导入行为。 注意2： 包名需要满足标识符的命名规则

注意： from 包名 import * 必须在 init.py 文件中添加 all = [] ，控制允许导入的模块列表
###输出当前时间
import datetime
now=datetime.datetime.now()
print(type(now.year))