一、導(dǎo)入模塊

1.導(dǎo)入模塊
python中一個py文件就是一個模塊。
可以通過import或者from-import在一個模塊中去使用另一個模塊的內(nèi)容

import 模塊名 ---> 將模塊中所有的內(nèi)容都導(dǎo)入,并且可以在當(dāng)前模塊中通過'模塊名.'的方式去使用模塊中的所有全局變量
from 模塊名 import 變量1, 變量2，.... ---> 將模塊中所有的內(nèi)容都導(dǎo)入。但是只能使用import后面的變量
from 模塊名 import * --->將模塊中所有的內(nèi)容都導(dǎo)入， 可以直接使用模塊中的所有全局變量

代碼執(zhí)行到import的時候，會將import后面的模塊的內(nèi)容執(zhí)行一遍

import test1

# 使用test1中的整型變量test_a
print(test1.test_a + 100)

# 使用test1中的函數(shù)test1_func1
test1.test1_func1()

from test1 import test_a, test1_func1
from test1 import *
print('當(dāng)前模塊:', test_a)
print(test1_func1())

print(name)
name = '張三'

2.重命名
import 模塊名 as 模塊的新名字 --> 給模塊重命名，使用模塊的時候用新的名字來使用
from 模塊名 import 變量名1 as 新名1, 變量名2 --> 給部分變量重新命名

 import test1 as TS

 print(TS.name)
 from test1 import name as test1_name, test1_func1 as other_func, test_a
 print(name)  # 使用當(dāng)前模塊的name變量
 print(test1_name)  # 使用test1中的name
other_func()
 print(test_a)

3.import：可以檢查被導(dǎo)入的內(nèi)容之前是否已經(jīng)導(dǎo)入過，如果導(dǎo)入過，不會再重復(fù)導(dǎo)入

# 導(dǎo)入多次，但是只執(zhí)行一次。多種導(dǎo)入的效果可以同時生效
import test1
# import test1
from test1 import test_a as AA
print(test1.test_a, AA)

二、選擇性導(dǎo)入（阻止導(dǎo)入）

1.阻止導(dǎo)入的方法：
if name == 'main':
代碼塊

說明:
if name == 'main': ---> 固定寫法
代碼塊 ---> 直接執(zhí)行當(dāng)前模塊，代碼塊會被執(zhí)行。如果在別的模塊中被導(dǎo)入，代碼塊不會執(zhí)行

2.每一個模塊都有一個name屬性， 這個屬性的默認(rèn)值是當(dāng)前模塊對應(yīng)py文件的文件名。
當(dāng)當(dāng)前模塊正被執(zhí)行(直接)的時候，系統(tǒng)會自動將模塊的name屬性變成'main'

import test1

3.什么時候使用模塊
將具有相同的功能的函數(shù)和數(shù)據(jù)封裝到一起

# import random
import math

# import random
# (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))

import color    #調(diào)用顏色函數(shù)

(255, 255, 255)
color.white    #調(diào)用函數(shù)中的白色函數(shù)
color.white
color.red
color.randow_color()

三、迭代器

1.什么是迭代器（iter）
迭代器是python中一種容器類的數(shù)據(jù)類型。屬于序列。沒有具體的字面量,可以將其他的序列轉(zhuǎn)換成迭代器：iter(序列)

2.迭代器的特點(diǎn)
只能通過next方法去一個一個按順序獲取迭代器中的元素，取出后迭代器中就不存在這個元素了

iter1 = iter('abcd')
print(iter1)

print(next(iter1))
print(next(iter1))

for x in range(5):
    print(x)

print(next(iter1))
print(next(iter1))
# print(next(iter1))  # StopIteration

3.遍歷迭代器

iter1 = iter(['abc', 10, 'name'])
print('=====')
for x in iter1:
    print(x)    #  abc  10  name
# print(next(iter1))    # StopIteration  遍歷已經(jīng)取完了，再取就會報錯
print('====')

# print(next(iter1))

next(迭代器)
迭代器.next()

iter2 = iter((1, 2, 3))
a = iter2.__next__()
print(a)  # 1

list1 = list(iter2)
print(list1)  # [2, 3]    之前取出了iter2中的第一個函數(shù)

四、生成式和生成器

1.什么是生成器
生成器就是迭代器，但是迭代器不一定是生成器

生成式就是生成器的一種特殊形式：(變量 for 變量 in 序列)

產(chǎn)生一個生成器，生成器中可以生成的數(shù)據(jù)是數(shù)字0~4（每個元素是數(shù)字）

ge1 = (x for x in range(5))
print(ge1)

print(next(ge1))   #0
print(next(ge1))   #1

print('=========')
for item in ge1:
    print(item)   #2  3  4

ge2 = (x*2 for x in range(5))
print('=========')
for item in ge2:
    print(item)     #0   2    4    6    8

ge2 = ([x, x*2] for x in 'abc')
print(next(ge2))     # ['a','aa']

print('===========')
ge2 = (x for x in range(5) if x%2)

for item in ge2:     
    print(item)     #  1   3 

2.生成器就是函數(shù)體中有yield關(guān)鍵字的函數(shù)
--> (函數(shù)中只要有yield，那么調(diào)用這個函數(shù)不再是執(zhí)行函數(shù)體并且獲取返回值，而是產(chǎn)生一個生成器)

通過next獲取生成器的元素的時候，會去執(zhí)行生成器對應(yīng)的函數(shù)的函數(shù)體，執(zhí)行到y(tǒng)ield為止，并且將yield后面的值作為返回值(元素值)。
然后保存當(dāng)前結(jié)束的位置，下次一獲取生成器的元素的時候會接著上次結(jié)束位置往后執(zhí)行，執(zhí)行到y(tǒng)ield.....

生成器可以當(dāng)成序列來使用

print('============')
def func1(n):
    print('你好，生成器!!')
    for x in range(n+1):
        print(x)
        yield x
        print('yeye')

ge3 = func1(3)    
print(ge3)       #<generator object func1 at 0x007419F0>

print('=:',next(ge3))  #    0
print('=:',next(ge3))  # 1
print(next(ge3))  #  2
print(next(ge3))  # 3
# print(next(ge3))

def func2():
    str1 = 'abcdef'
    index = 0
    while index < len(str1):
        yield str1[index]
        index += 1
ge4 = func2()
print(next(ge4))   #a 
#
print(next(ge4))   #b
print(list(ge4))   #['c', 'd', 'e', 'f']

def func3():
    num = 0
    while True:
        yield num
        num += 1
ge5 = func3()
print(ge5)   
print('==:',next(ge5))   #0
print('==:',next(ge5))   #1

print('========')
for _ in range(5, 100):
    print(next(ge5))   #2-99

print('=======')
print(next(ge5))

生成器生成的數(shù)據(jù)的規(guī)律：奇數(shù)就返回他本身，偶數(shù)就返回它的2倍

def func2(n):
    for x in range(n):
        yield x, 2*x, 3*x
        # yield 2*x
        # yield 3*x
        # if x%2:
        #     yield x
        # else:
        #     yield x*2

g6 = func2(5) 
print(next(g6))    # 0  0   0
print(next(g6))    # 1   2   3
print(next(g6))    #2    4   6

五、文件的讀與寫

文件一旦編寫，就做本地化，注釋掉代碼也不會恢復(fù)。
前面打印出來的也會改變打印目前文件數(shù)據(jù)。
使用文件可以做數(shù)據(jù)的持久化(本地化) ---> 數(shù)據(jù)庫文件，txt、json，plist，二進(jìn)制文件

1.文件操作 -- 讀寫操作
讀 -> 取出文件中的數(shù)據(jù)
寫 -> 將數(shù)據(jù)寫到文件中

所有文件操作的過程：打開文件 --> 操作文件 --> 關(guān)閉文件

2.打開文件和關(guān)閉文件
open(file, mode='r',encoding=None)

a.file -> 文件路徑(必須傳參)，決定需要打開的是哪個文件

絕對路徑（不推薦使用）
相對路徑: /|相對路徑 (相對路徑是相對當(dāng)前py文件對應(yīng)的文件夾)
./ ---> 當(dāng)前文件夾
../ --> 當(dāng)前文件夾的上層文件夾
.../ --> 當(dāng)前文件夾的上層文件夾的上層文件夾

b.mode -> 文件打開方式（不同的操作對應(yīng)不同的打開方式）

'r' --> 以只讀的形式打開文件, 文本
'rb'/'br' --> 讀操作，讀出來的數(shù)據(jù)是二進(jìn)制形式的數(shù)據(jù)
'w' --> 以寫的形式打開文件
'bw'/'wb' --> 寫操作，將二進(jìn)制數(shù)據(jù)寫入文件
'a' --> 寫操作，追加

c.encoding -> 文本文件的編碼方式

utf-8 :幾乎支持所有的語言文字
gbk : 只支持英文

d.open函數(shù)的返回值，就被打開的文件對象

關(guān)閉文件: 文件對象.close()

==============文件的讀操================
1.打開文件

f1 = open('./test1.txt', 'r', encoding='utf-8')

2.讀文件中的內(nèi)容

文件對象.read() --> 從文件開始的位置讀到文件結(jié)束,返回讀到的結(jié)果
文件對象.readline() --> 讀一行
文件對象.readlines() --> 返回一個列表，列表的元素是文件中每一行的內(nèi)容

content = f1.read()
print(type(content), content)

# print('==:', f1.read())

# content = f1.readlines()
# print(content)

3.關(guān)閉文件

f1.close()

===========文件的寫操作=================
1.打開文件

'w' -> 將字符串寫入文件中， 完全覆蓋文件原來的內(nèi)容
'wb'/'bw' -> 將二進(jìn)制寫入文件中, 完全覆蓋文件原來的內(nèi)容

'a' -> 追加

f2 = open('./test1.txt', 'w', encoding='utf-8')

2.寫入文件

# f2.write(content+'hello world')
f2.writelines(['abc\n', '123\n', 'aaaaa\n'])