PYTHON 跟着娟姐

第一章

1 IPO

IPO指的是输入处理输出

2 input

1 X=input("提示文字: ")

        注意事项：无论输入的数据是什么，X的数据类型都是字符串类型。如果想输入整数型数据在input前加int -->

 X = int(input(""))

print("请输入数字"，X)    注：此时符号必须是逗号了

3 中文文档声明注释

一定要写在第一行 

# coding = utf-8

4 代码缩进

类定义，函数定义，流程控制语句以及异常处理语句等结尾的冒号和下一行的缩进表示一个代码块的开始，而缩进结束，则表示一个代码块的结束，通常情况下，采用四个空格作为一个缩进量。

5 print

print函数完成的语法格式为：

print(value,...,sep = "",end = "\n",file =None) file表示可以把内容输入到文件当中

实战练习

把"人生苦短"输入到"text,txt"中。

file = open("text,txt","w")

print("人生苦短",file =file)

file.close()

第二章 数据类型和运算符

1 保留字

指在python中被赋予特定意义的一些单词，在开发程序时，不可以把这些保留字作为变量，函数，类，模块和其他对象名称来使用：

import keyword

print(keyword.kwlist)

and as assert break class continue def del elif else except finally for from False global if import in is lambda nonlocal not None or pass raise return try true while with yield await async(35个)

2 标识符

标识符命名规则：1可以是字符（中文/英文）、下划线和数字，并且第一个字符不能是数字

2 不能使用保留字 3 严格区分大小写 4允许使用中文开头但是不建议，

标识符其实就是变量的名字

3 变量和常量

python允许多个变量指向同一个值

no = number = 88

print(id(no)) #67337

print(id(number)) #67337

常量：在程序运行中，值不允许改变的量 。命名规则：全部使用大写字母和下划线命名。

例：PI =3.1415926

4 数据类型

4.1整数类型（不可变数据类型）

    ：数值部分没有小数部分，包含正整数，负整数和 0 表示形式有2进制（0b开头,10进制 ,8进制 （0o开头),16进制（ox开头）。

4.2浮点数类型（不可变数据类型）

     ：带有小数部分的值，包含小数部分和整数部分

        注2个小数相加时，有一定的概率运算加过后增加一些不确定尾数 0.1+0.2 =0.30000009

4.3字符串类型（不可变数据类型）

可以使用单引号，双引号和三引号来表示

转义字符 \n 换行

                \t 水平制表位，用于横向跳到下一个制表位

                \" 双引号

                \'单引号

                \\一个反斜杠

                r"http\c:\d.file.txet" r后的转移字符就失效了。

4.3.1切片-->【N:M】

对字符串的子串或者区间的检索叫切片。

print(s[-8:-3])  llowo

print(s[2:7])     llowo

4.4布尔类型

每个对象都是一个布尔值 可以用BOOL验证

所有非空字符串的布尔值都是true

4.5数据类型之间的转换

隐形转换 在运算中字段转换了 print（True+8）

显示转化

int(x) 将x转换成整数类型                           float(x) 将x转换成浮点数类型       

str(x) 将x转换成字符串类型                        chr(x) 将整数x转换一个字符      

ord(x) 将一个字符x转换为其对应的整数值     

hex(x) 将整数x转换为一个十六进制的字符串

oct(x) 将整数x转换为一个八进制的字符串

bin(x) 将整数x转换为一个二进制的字符串

5 eval函数

用于去掉字符串最外侧的引号，并按照python语句方式执行去掉引号后的字符串，常与input一起使用

s = "3.13+4"

print(eval(s)) --> 7.13000001  去掉了引号并执行了里边的运算。

hello = "北京欢迎你"

print（eval（”hello“）） -->北京欢迎你 注：hello加了引号

但是print（eval（ "北京欢迎你"））会报错

6 算数运算符

+       -       *        /除法      //整除       %取余        ** 幂运算

7赋值运算符

+=       -=       *=        /=      //=     %=       **=

例子

X =10

Y = 20

X = X+Y 相当于 X+=Y 

--->30

8比较运算符

>    <   ==    !=  <=   >=

9位运算符：把数字看作二进制数来计算

按位与 &  and  1换成二进制，2位数对齐，上下对齐 3and运算

按位或 |     or    1换成二进制，2位数对齐，上下进行 3or运算

按位异或 ^        1换成二进制，2位数对齐，上下进行 32个数相同就是0 不同就是1

按位反 ~           1换成二进制 原来是1 变成0，原来是0 变成1

左位移 <<    1换成二进制 向左移2位 其余补0     左乘

右位移>>     1换成二进制 向右移2位 高位是0补0，高位是1 补1  右除

10运算优先级

（）

**  

~    

+ 正号

-负号

* / % //

+加法  -减法

<<   >>

& ^ |

< <= > >= != ==  =

第三章 程序的流程控制

1顺序语句

由上到下顺序执行

2选择结构

if 表达式：

        语句块

当语句块只有一句话时可以直接写在冒号后边

a =8

b= 4

if a>b:max=a

print(max)    -->8

3双分支结构 if...else

if 表达式：

        语句块

else：

        语句块

写成一句 ：

print（”恭喜您中奖了“ if number = "9988" else "您未中奖"）

4多分支结构（可以没有else）

if 表达式：

        语句块

elif 表达式：

        语句块

else：

        语句块

例：

socre = eval(input("请输入成绩："))

if score<0 or score>100:

        print("成绩有误")

elif 60<score<100:

        print("及格")

else:

            print("不及格")

5嵌套if的使用

if 表达式：

        if 表达式：

                语句块

        esle：

                语句块

else：

        语句块

6循环结构

6.1模式匹配：match case 语句

score = input（”请输入成绩：“）

match score：

        case ”A“:

                print("优秀")

        case ”A“     

                  print("良好") 

        case ”A“

                  print("及格")

        case ”A“

                  print("不及格")

6.2 for循环

内置函数range(n:m) 包含n不包含m

6.3while循环 无限循环的结构

while 表达式

        语句快

else：

        语句块

while循环的四个步骤

1 初始化变量 2 条件判断 3 语句快 4 改变变量

s = 0

i = 13（1 初始化变量 ）

while i<=100: #（2 条件判断）

        s+=i #（3 语句快）

        i+=1   #（ 4 改变变量）

 else：

            print("一到100的累加是'，s)

例：模拟登录账号密码

i = 0  （初始化变量）

while i<3:

       a =  input("请输入账号;")

       b =  input("请输入密码;")

        if a =="zxj" and b=="888888": （判断条件）

                print("你的账号密码输入正确，请稍等。。。")（语句块）

                i = 8         （改变变量）

        else：（判断条件）

                if i<2:

                        print("密码输入错误，你还有"，2-i，”次机会“)

                i+=1   （改变变量）

if i ==3:

        print（”密码错误3次，请明天再试“）

6.4嵌套循环

for表达式：

        语句块

for表达式：

        语句块

当有2个for 并列时，for语句同时执行

6.5break常用for 一起使用

i = 0

while i<3:

       a =  input("请输入账号;")

       b =  input("请输入密码;")

        if a =="zxj" and b=="888888":

                print("你的账号密码输入正确，请稍等。。。")

                break

        else：

                if i<2:

                        print("密码输入错误，你还有"，2-i，”次机会“)

         i+=1（改变变量 位置式while后空四个格）

else：

        print（”密码错误3次，请明天再试“）

6.6 continue

用于跳过本次循环的后续代码，而继续执行下一次循环操作，continue在循环中通常也是与if一起搭配使用的

s=0

i=0

while i<100:

        if i%2 =1:

                i+=1

                continue

        s+=i

        i=+1

print("1-100之间的偶数和是"，s)

6.7 pass

在语法结果中起到占位符的作用，使语法结构完整，不报错，

第四章 组合数据类型

1 序列和索引

序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称之为索引。

索引有正向递增和反向递减索引

s[start:end:stop] start可以省略默认为0 end可以省略默认为最后 stop可以省略默认为1

例如

s="helloworld"

s[;;2]-->hlool s[1::4]-->eor

1.1序列常用的函数

s = "helloworld"

1.11操作符 in ,not in,

1.12内置函数 len(s), max(s), min(s),

1.13方法   s.index("o")，s.count（"o"）

2 列表[]

2.1定义：

是指一系列按照特定顺序排列的元素组成

是python中内置的可变序列

在python中使用【】定义列表，元素之间用英文逗号隔开，

列表中的元素可以是任意的数据类型

2.11 为什么要使用列表

变量可以存储一个元素，而列表是一个大"容器"可以存储多个元素，程序可以方便的对这些数据进行整体操作

2.2创建列表的2种方法

1 直接用【】:  s=[1,2,3]      2  使用list :  s= list("helloworld")

列表是序列的一种，对序列操作符，运算符，函数都可以使用

2.3列表的删除的方式 del 和clear

str = ["qwr"]

del str -->把值和列表名彻底删除

str.clear() --> 清除列表中的值

2.4 enumerate:枚举

列表的遍历

方法1

str = ["hello","any","all"]

for i in str:

        print(i)

方式2

for i in range(len(str)):

        print(s[i])

方式三 enumerate index是序号不是索引，可以修改 ，也可以不写start 直接写1也行

for index，item in enumerate（str，start=1）：

        print（index，item）

2.5列表的相关操作方法

lst.append(x)         在列表lst最后增加一个元素  添加之前的list和添加之后的list id不变。

lst.insert(index,x)   在列表中第index位置添加一个元素 id不变

lst.extend()        在列表末尾的位置上添加n个元素。id不变

切片：在列表任意的位置上添加至少一个元素   id不变

lst.clear()               清除列表中所有的元素

lst.pop(index)       将列表lst中第index位置的元素取出，并删除

lst.remove(x)        将列表中出现的第一个元素x删除

lst.reverse(x)        将列表反转

lst.copy()              拷贝列表中的所有元素，并生成新的列表

2.5.列表2种排序的方法

1 sort  lst.sort(key = None,reverse = False)   key表示排序规则，reverse = False默认升序

排序是在原列表上进行的，不会产生新的列表

举例

lst = [4,56,7,65]

lst.sort()

print(lst)  --> 4,7,56,65

2 sorted   sorted(interable,key = None,reverse = False) iterable：排序的对象

排序是在不是原列表上进行的，需要产生新的列表

lst = [4,56,7,65]

new_lst= sorted(lst)

print(new_lst)  --> 4,7,56,65

2.6创建列表的第三种方式 lst=[expression for  item in range]

lst = [item for item in range(10)]

import random

lst = [random,randint(1,100) for _ in range(10)]

注可以不用i或者item 用下划线也可以，循环10次，每次产生一个1-100直接的整数

2.7二层循环的break和contniue

内层的break会跳出内层循环但是不影响外层循环，

内存的continue会继续内层的循环同时也不影响外层的循环.

 for i in range(5):
    for j in range(1,11):
        if j%2==0:
            break
        print(j)
# ---> 1,1,1,1,1

 for i in range(5):
    for j in range(1,11):
        if j%2==0:
            continue
        print(j,end = "\t")
# ---> 1,3,5,7,9
# ---> 1,3,5,7,9
# ---> 1,3,5,7,9
# ---> 1,3,5,7,9
# ---> 1,3,5,7,9

2.8列表的特点总结

一、列表元素按顺序有序排序

二、索引映射唯一的一个数据

三、列表可以存储重复数据

四、任意数据类型混存

五、根据需要动态分配和回收内存

2.9列表的查询操作

2.9.1获取列表中指定元素的索引

                  1 如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引

index（）   2 如果查询的元素在列表中不存在，则会抛出ValueError

                   3 还可以在指定的start和stop之间进行查找

举例3 lst = ["hello","world","98"]

print(lst.index(”hello",1,3))

                                               正向索引从0-N-1 举例：lst[0]

获取列表中的单个元素            逆向索引从-N到-1 举例：lst[-N]

                                                指定索引不存在，则抛出ValueError

print(lst[-1]) -->98

2.9.2获取列表的多个元素-切片

[start,end,step] 左闭右开，默认步长为1，切出来的列表是一个新的列表对象。id与原lst不一样了。

lst = [10,20,30,40,50,60,70,80]

lst2 = lst[0:2:1]

print(lst2)-->10,20

当step为负数时：就说明是从后往前倒着数的，因此start和end为正时必须 start大于end

例如lst[3:0:-1]

当start和end为负时，也必须start大于end 例如 lst[-3:-7:-1]

lst3 =lst[3:0:-1]

注意：当star和end为负数时，是列表的从后往前数的序列号，只是序号的不同叫法而已，当step为负数时，是后往前数的，所以如果这么写lst4 = lst[-3:-1:-2] --结果为空。

2.9.3列表的排序

sort ，id不变

sorted 产生一个新的列表对象，默认为升序，即reverse = false

2.10 列表生成式

语法格式为:

    lst =    [ i *i for i in range(1,10)]

    lst =    [4*4 for i in range(6)]

3 字典{key:value}

1 什么是字典

字典是python内置的数据结构之一，与列表一样是一个可变序列，以键值对的方式存储数据，字典是一个无序的序列。用{}装，键不可变 可有字符串和整数序列来表示，值可变

2 字典的创建

1 使用花括号

score = {"张三"："100","李四"："50"}

2 内置函数dict

dict(name = "jack",age=20)

dic = dict{}   # 创建了一个空字典

3 字典的常见操作

3.1获取字典的元素

dic["name"]    和   dic.get("name")都可以。

3.2获取字典的键 in not in

print（"jack" in dic）

3.3删除键值对 del

del dic["jack"]

3.4清空字典clear

dic.clear()

3.5 新增一个键值对

dic["sex"]=female

3.6字典的视图操作

keys()  获取所有的健 dic.keys()

values() 获取所有值

items() 获取所有的键值对

3.7字典元素的遍历

for item,value in scores:

        print(item) #item输出的是键

        print(item，scores[item],scores.get(item)) #item输出的是键和健和值

3.8字典生产式

{item.upper():price for item,price in  zip (items,prices)}

4 元组()

1 什么是元组

python 内置函数之一，是一个不可变序列，使用的是小括号和逗号

什么是可变序列和不可变序列

2 元组的创建

1使用() : a = ("java","py",98) 或者 a="java","py",98,当只有一个元素时需要加逗号 a=(98,)

注：括号可以不写

空元组的创建 a = （）

2使用tuple a=tuple( ("java","py",98))

3 为什么把元组设计成不可变序列

：在多任务环境下，同时操作对象时不需要加锁，因此元组设计成不可变序列。

4 元组的遍历

for i in t():

5 集合{}

1 什么是集合 （无序，不允许重复）

python内置的数据结构，与列表、字典一样属于可变类型的序列，集合是没有value的字典。

2 集合的创建

使用{}， s={2，4，5，6，7，7，8，0}

使用set() ,s=set(2,3,4,5,6,5,8,8)

s=set(range(6))

s =set([2,3,4,5,6,4,32])

s =set((2,3,4,5,6,4,32))

s =set({2,3,4,5,6,4,32})

s =set("python")

定义一个空集合

s=set()

3 集合的相关操作

3.1 in 和not in

3.2 集合的新增操作

add（）一次添加一个元素      s.add(80)

update（）至少添加一个元素   s.update({100,200,500}) {}还可以换成[] ()

3.3集合的删除操作

remove()  和 discard（）删除一个元素，元素不存在时discard不报错

pop() pop的括号内不写东西，任意删一个。

clear()清空集合

3.4 集合之间的关系

==  ！=

当2个集合元素相同时 2个集合相等==

issubset：当一个集合是另一个集合的子集时

issuperset：当一个集合是另一个集合的超集时

isdisjoint：判断2个集合没有交集， 有交集显示false  没交集时显示true

intersection / & ：求2个集合的交集元素

union /  |： 求2个集合的交并集元素

difference/-: 差集元素

symmertric_difference：对称差集元素

[50,60,70].symmertric_difference[70,80,90]-->[50,80,90]

3.5 集合生成式

{i*i for i in range(1,10)}

4 列表 字典 元组 集合总结

6 字符串" ", ',' """ """, '''  '''

字符串的驻留机制

在python中字符串是基础数据类型，是一个不可变的字符序列。

什么是字符串驻留机制呢？

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

a = “python”

b = “python”

c = “python”

print(id(a),id(b),id(c))

-->2693075835504 2693075835504 2693075835504

驻留机制在什么情况下能成功（交互模式）

     1   字符串的长度为0或者1时

     2   符合标识符的字符串

     3  字符串只在编译时进行驻留，而非运行时  例子： a="abc"  c=",".join(["ab","c"])

     4  [-5,256]之间的整数数字  a=-5,b=-5 a is b , a=-6 b=-6  a is not b

1 字符串常见操作

查找

rindex s.rindex()查找字符串中的子串第一次出现的位置索引 --从右往左开始找  找不到会报错

index  s.index()查找字符串中的子串第一次出现的位置索引-- 找不到会报错

rfind   s.rfind()查找字符串中的子串第一次出现的位置索引-- 从右往左开始找  找不到不会报错

find  s.find()查找字符串中的子串第一次出现的位置索引-- 找不到不会报错

大小写转换

upper（）：会产生新的字符串，新的id

lower（）：会产生新的字符串，新的id

swapcase()   ：大小写转换

capitalize():  首字母大写，其余小写，会产生新的字符串，新的id

title():     每个单词的首字母大写，其余小写，会产生新的字符串，新的id

字符串内容对齐的操作方法

center（20,"*"）：中间对齐 a指的是给的字符宽度，b是用于对齐补充的符号 ，不写默认为空格
ljust(20,"*")   :左对齐

rjust(20,"*")   :右对齐

zfill(20):右对齐，用0填充

字符串的分割操作

split（）:默认用空格分割，或者s.split(sep = "|")

rsplit（）：默认从右开始分割 s.rsplit(sep ="|",maxsplit =1) #maxsplit最大分割的次数

isidentifier() : 检查是否是标准的标识符。

isspace():判断指定的字符串是否全部由空白字符组成（回车 换行 水平制表符）

isalpha（）：是否全部由字母构成。

isdecimal():判断是否是十进制的数字组成

isnumberic():判断指定的字符串是否全部由数字组成

isalnum():判断指定字符串是否全部由字母和数字组成

字符串的替换与合并

replace("原字符串","新字符串",替换的个数（不写默认全部替换）):

合并 join

字符串的比较操作

>  >=  < <=

比较2个字符串的大小，先比较第一个字符的大小如果相等就继续比较2个字符串的第二个字符，以此类推，比较时使用的是内置函数ord，使用chr可以得到对应的字符

print("apple">"app")

== 与is 的区别

==：比较的是value是否相等

is：比较的是id是否相等

字符串的切片操作

字符串是不可变类型，不具备增，删，改等操作，切片将会产生新的对象。

[start:end:step]

格式化字符串 % \{}和 f

name = "张三"

age = 18

1 print("我叫%s，今年%d岁了" %（name,age）)

2 print("我叫{0}，今年{1}岁了" .format（name,age）)

3 print(f" 我叫{name}，今年{age}岁了" )

%d  和%f

字符串的编码转换

在gbk这种编码格式中， 一个中文占2个字节。

在utf-8这种编码格式中，一个中文占3个字节。

第五章 函数

什么是函数：执行特定的任务和完成特定功能的代码

为什么要使用函数：

1 复用代码  2 隐藏实现细节   3  提高可维护性  4 提高可读性便于调试

函数的创建：

def 函数名（[参数]）：

        函数体

        [return xxxx]

1 函数调用参数

形参，位置参数和关键字参数

2 函数的参数传递的内存分析

3 函数的返回值

（1）：如果函数没有返回值，【函数执行完毕后，不需要给调用出提供数据】可以不写return

（2）：函数的返回值，如果是一个，直接返回原类型

（3）：函数的返回值，如果是多个，返回的结果为元组

4 函数的默认值

函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参。

def fuc（a,b=10）# b=10 10就是默认值。

        print(a+b)

5 个数可变的位置参数和个数可变的关键字参数

个数可变的位置参数

：定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数

1 使用 * 定义个数可变的位置参数

2 结果为一个元组

个数可变的关键字形参

：定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参

1 使用 ** 定义个数可变的关键字形参

2 结果为一个字典

6 变量的作用域

程序代码能访问改变量的区域

根据变量的有效范围可分为

1 局部变量：在函数定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会变成全局变量

2 全局变量：在函数体外的定义的变量，可作用于函数内外

7 递归函数

什么时递归函数：

        如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

递归函数的组成部分：

        递归调用与递归终止条件

递归的调用过程：

        每递归调用一次函数，都会在栈内存分配一个栈帧

        每执行完一次函数，都会释放相应空间

递归的优缺点：

        缺点;占用内存多，效率低下

        优点：思路和代码简单

def func（n):

        if n==1:

                return 1

        else:

                return *func(n-1)

8 常用的bug类型：

语法错误：SyntaxError

知识点不熟悉引发的错误：IndexError

思路不清晰的错误：

try-except

try-except-else

try-except-else=finally

9 python 中常见的错误类型

1 ZeroDivisionError：除0错误

2 IndexError：序列中没有此索引

3 KeyError：映射中没有这个健

4 NameError：未声明/初始化对象

5 ValueError：传入无效参数

10 异常处理机制traceback

使用traceback查看报错类型

第六章 编程的两大思想

1 面向过程和面向对象

面向过程：事务比较简单，可以用线性的思维去解决，

面向对象：事务比较复杂，使用简单的线性思维无法解决

共同点：面向过程和面向对象都是解决实际问题的一种思维方式

二者相辅相成，并不是对立的，解决复杂的问题，通过面向对象的方式便于我们从宏观上把握事物之间复杂的关系，方便我们分析整个系统，具体到微观操作，仍然使用面向过程方式来处理

2 类与对象

类：是多个类似事务组成的群体的统称，能够帮助我们快速理解和判断事务的性质。

鞋：凉鞋 、皮鞋、草鞋、拖鞋。

对象：100.99.230都是int类之下包含的相似的不同个例，这个个例专业术语称为实例或者对象。

在python中一切皆对象.

2.1 类

类的创建：

class Student：# 类名首字符大写

        pass

类属性：类中方法外的变量成为类属性，被该类是所有对象共享。

类方法：使用@classmethod修饰的方法，使用类名直接访问的方法。

静态方法：使用@staticmethod修饰的方法，使用类名直接访问的方法

Student.native_place  # 访问类属性

Student.cm()# 调用类方法

Student.sm()#  调用静态方法

2.2 动态绑定属性和方法

给实例对象新加一个原来没有的方法和属性

使用时 类属性不加括号，静态动态实例化都加（）

stu.native_pace,              stu.cm(),stu_sm() stu.eat()

stu2.gender = "女"

                                                    动态绑定属性

                                                        动态绑定方法

2.3 面向对象的三大特征 -封装-继承-多态

2.3.1封装：

提高程序的安全性：将数据（属性）和行为（方法）包装到类对象中，在方法内部对属性进行，在类对象的外部调用方法，这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。

在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个"__"

继承：提高代码的复用性。

多态：提高程序的可扩展性和可维护性。

2.3.2 继承

在python中支持多继承

继承之-方法重写

object 类：

        是所有类的父类，因此所有类都有object类的属性和方法。

        内置函数dir()可以查看指定对象的所有属性

        object有一个__str__()方法，用于返回一个对于”对象的描述“，对应内置函数str()经常用于print()方法，帮我们查看对象信息，所以我们经常会对__str__()进行重写。

2.3.3 多态

        简单的说，多态就是具有多种形态，它指的是，即使不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。

特殊属性和方法

2.4 浅拷贝和深拷贝

变量的赋值操作：

        只是形成两个变量，实际上还是指向同一个对象

浅拷贝：

        python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象

深拷贝:

        使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。

第七章 模块

什么叫模块：

一个模块可以包含多个函数，在python中，一个扩展名为.py的文件就叫一个模块，

使用模块的好处：

方便其他程序和脚本的导入和使用

避免函数名和变量名冲突

提高代码的可维护性

提高代码的可重用性

模块的导入：

import 模块名称 as 别名

from 模块名称 import 函数/变量/类

以主程序形式运行：

        在每个模块的i定义中都包含一个记录模块名称的变量__name__,程序可以检查该变量，以确定他们在哪个模块中运行，如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶级模块中运行，顶级模块的__name__变量的值为__main__.

if __name__ = "__main__":

        pass

jupiter不能直接import后缀为ipynb的文件，所以要先将后缀为ipynb的文件download为.py文件，再把.py文件重新上传到jupiter。

第八章 python中的包

包中包含一个__init__.py的文件的文件夹，整个文件可以有代码也可以没有代码

可以避免模块名称冲入的问题

1 python的内置模块

1.1 random模块

1.2 time 模块

1.3 datetime

datetime的timedelta类的使用