長(zhǎng)期置頂：

基礎(chǔ)教程: http://www.cnblogs.com/dahu-daqing/p/6629577.html

基礎(chǔ)教程: http://www.cnblogs.com/linhaifeng/p/7278389.html

爬蟲教程: http://www.cnblogs.com/linhaifeng/p/8241221.html

2018-02-07

socket

• https://www.cnblogs.com/alex3714/articles/5830365.html
• socket.SOCK_RAW 可用于 DDoS 攻擊

簡(jiǎn)單 socket 例子（需要先啟動(dòng)服務(wù)端）

• 客戶端

# Author:Freeman
import socket

client = socket.socket()  # 聲明 socket 類型,同時(shí)生成socket連接對(duì)象,參數(shù)沒填,但是有默認(rèn)參數(shù)
client.connect(("localhost", 6969))

client.send(b"Hello World!")  #py3 不再允許字符串,需要 bytes 類型,bytes類型只能接受ASCII碼,因此這里如果想要輸入漢字：
# client.send("你好,世界!".encode("utf-8"))  # 接受時(shí)需要 decode 解碼為 Unicode
data = client.recv(1024)  # 最多接收1024個(gè)字節(jié)
print("recv:", data)
client.close()

• 服務(wù)端

# Author:Freeman
import socket

server = socket.socket()
server.bind(("localhost", 6969))  # 綁定要監(jiān)聽的端口
server.listen()  # 監(jiān)聽
print("準(zhǔn)備接收信息")
conn, addr = server.accept()  # 服務(wù)端需要等信息傳進(jìn)來
print(conn)
# conn:就是客戶端連過來,而在服務(wù)器端為其生成的一個(gè)實(shí)例
# <socket.socket fd=484, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 6969)

print(addr)  # IP + 隨機(jī)端口
print("接收信息")
data = conn.recv(1024)
print("recv:", data)
conn.send(data.upper())
server.close()

• 實(shí)現(xiàn)類似接打電話的過程颜说，A與B通話畦粮，這時(shí)C給A打來電話時(shí)先等待闯估，等到A與B斷開之后再接入C
• 操作過程:
  1.先啟動(dòng)服務(wù)端
  2.啟動(dòng)客戶端，并在客戶端輸入文字："客戶端1"
  3.再啟動(dòng)客戶端裤唠，在新客戶端輸入文字：“客戶端2”
  4.斷開客戶端1（注意，不是紅色方塊拴测，是下面的紅叉）垫蛆，查看 server 結(jié)果

# 服務(wù)端

import socket

server = socket.socket()
server.bind(("localhost", 6969))  # 綁定要監(jiān)聽的端口
server.listen()  # 監(jiān)聽
print("準(zhǔn)備接收信息")
while True:
    conn, addr = server.accept()  # 服務(wù)端需要等信息傳進(jìn)來
    while True:
        data = conn.recv(1024)
        if not data:
            print("客戶端斷開")
            break
        print("recv:", data.decode())
        conn.send(data.upper())  # upper() 轉(zhuǎn)大寫.將收到的數(shù)據(jù)轉(zhuǎn)換為大寫發(fā)送回客戶端
server.close()

# 客戶端
import socket

client = socket.socket()  # 聲明 socket 類型,同時(shí)生成socket連接對(duì)象
client.connect(("localhost", 6969))

while True:
    msg = input(">>:").strip()
    # client.send(b"Hello World!")
    client.send(msg.encode("utf-8"))

    data = client.recv(1024)  # 接收1024個(gè)字節(jié)
    print("recv:", data.decode())
client.close()

2018-02-06

• https://www.cnblogs.com/alex3714/articles/5213184.html
• 寫類時(shí)要加上注釋

# Author:Gatling
class Person(object):
    # hahahaha
    '''描述信息'''

    def __init__(self, name):
        self.name = name
        # lalalala


print(Person.__doc__)       # 描述信息

• __new__ 是 用來調(diào)用 __init__

反射

異常處理

2018-02-05

靜態(tài)方法

• @staticmethod：這玩意也是個(gè)裝飾器，必須寫在類中的函數(shù)嗤攻，除此之外與類沒什么關(guān)系毛嫉，定義時(shí)有什么參數(shù)就得傳什么參數(shù)，跟函數(shù)一樣妇菱。在靜態(tài)方法里訪問不了類或?qū)嵗械娜魏螌傩院头椒?/li>

類方法

• @classmethod：只能調(diào)用 class 自身的變量承粤，無法訪問實(shí)例變量。例如一個(gè)類自身有name 屬性闯团，它的實(shí)例也具有 name 屬性辛臊，通常是先調(diào)用實(shí)例的name，但如果想強(qiáng)行調(diào)用 類 的 name 就可以用到了

屬性方法

• @property：把一個(gè)方法變成靜態(tài)屬性房交，調(diào)用時(shí)不能再添加括號(hào)

# Author:Gatling
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__food = None

    @property
    def eat(self):
        print("%s is %s years old,eating %s" % (self.name, self.age, self.__food))

    @eat.setter  # 傳參數(shù)
    def eat(self, food):
        print("set to food:", food)
        self.__food = food

    @eat.deleter
    def eat(self):
        del self.__food
        print("已刪除")


Freeman = Person("Freeman", 18)
Freeman.eat
Freeman.eat = "包子"
Freeman.eat

del Freeman.eat
Freeman.eat

# Freeman is 18 years old,eating None
# set to food: 包子
# Freeman is 18 years old,eating 包子
# 已刪除
# Traceback (most recent call last):
#   File "D:/ForPython/爬蟲.py", line 29, in <module>
#     Freeman.eat
#   File "D:/ForPython/爬蟲.py", line 10, in eat
#     print("%s is %s years old,eating %s" % (self.name, self.age, self.__food))
# AttributeError: 'Person' object has no attribute '_Person__food'

• 關(guān)于靜態(tài)屬性:https://www.cnblogs.com/alex3714/articles/5213184.html

2018-02-04

面向?qū)ο?/h3>

• http://www.cnblogs.com/alex3714/articles/5188179.html
• 基礎(chǔ)寫法

# 假設(shè)創(chuàng)建一個(gè)CS游戲：
# 有角色
# 射擊
# 中槍
# 買槍

class Role(object):
    # 構(gòu)造函數(shù)中的每個(gè)屬性在新實(shí)例化一個(gè)對(duì)象的時(shí)候都會(huì)創(chuàng)建一份
    # 而方法只在 Role 中,不會(huì)隨著新創(chuàng)建實(shí)例化對(duì)象而創(chuàng)建,每次調(diào)用的時(shí)候?qū)嶋H上是訪問 Role 這個(gè) class 中的方法
    def __init__(self, name, role, weapon, life_value=100, money=15000):
        # 構(gòu)造函數(shù)
        # 在實(shí)例化時(shí)做一些類的初始化的工作
        # self 用于在實(shí)例化時(shí)傳入'實(shí)例變量(靜態(tài)屬性)'(就是后面的 r1,r2)
        # self 的作用域就是 實(shí)例變量本身
        # Role(r1,..,..,..) 通過這樣的方式告訴 Role 它的'實(shí)例變量'是 r1
        self.name = name
        self.role = role
        self.weapon = weapon
        # self.life_value = life_value
        self.__life_value = life_value  # 私有屬性
        self.money = money

    def __del__(self):
        # 析構(gòu)函數(shù):在實(shí)例釋放或銷毀的時(shí)候自動(dòng)執(zhí)行的
        # 通常用于做一些收尾工作,如關(guān)閉數(shù)據(jù)庫連接或之前打開的臨時(shí)文件
        print("%s 觸發(fā)析構(gòu)函數(shù)" % self.name)

    def show_status(self):
        # 用于訪問私有屬性的函數(shù)
        # 私有屬性在外面無法直接訪問彻舰，因此只需要在內(nèi)部定義一個(gè)可以在外部調(diào)用的方法，然后在外面調(diào)用即可
        print("通過定義 show_status() 訪問到了私有屬性 __life_value:%s" % self.__life_value)

    def shot(self):  # 動(dòng)態(tài)屬性
        # 為什么這里有個(gè) self
        # 為了告訴這個(gè)函數(shù),'誰'調(diào)用了這個(gè)方法
        # 這里面的'誰'就是'實(shí)例化名',也就是r1,r2
        # r1.shot() == Role.shot(r1)
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")

    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name, gun_name))


r1 = Role('Alex', 'police', 'AK47')  # 實(shí)例化(初始化一個(gè)類,造了一個(gè)對(duì)象)

r2 = Role('Jack', 'terrorist', 'B22')
r1.buy_gun("Gatling")  # Alex just bought Gatling
# del r1    # 刪除 r1
# 補(bǔ)充個(gè)垃圾回收機(jī)制和 __del__ 析構(gòu)函數(shù)
# 進(jìn)行這個(gè)操作后,r1 變量被刪除,但 r1 所引用的內(nèi)存還存在
# Python 通過垃圾回收機(jī)制定期循環(huán)內(nèi)存,發(fā)現(xiàn) r1 引用的內(nèi)存地址還在,但 r1 已經(jīng)沒了
# 因此會(huì)認(rèn)定 r1 內(nèi)存地址已經(jīng)沒有用了,隨即進(jìn)行刪除
# __del__ 析構(gòu)函數(shù)就在此時(shí)觸發(fā)
r2.buy_gun(("Gatling"))

# print(r1.__life_value)  # 報(bào)錯(cuò)
r1.show_status()

# Alex just bought Gatling
# Jack just bought Gatling
# 通過定義 show_status() 訪問到了私有屬性 __life_value:100
# Alex 觸發(fā)析構(gòu)函數(shù)
# Jack 觸發(fā)析構(gòu)函數(shù)

---

繼承

class SchoolMember(object):
    members = 0  # 初始學(xué)校人數(shù)為0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def tell(self):
        pass

    def enroll(self):
        '''注冊(cè)'''
        SchoolMember.members += 1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " % (
            self.name, SchoolMember.members))

    def __del__(self):
        '''析構(gòu)方法'''
        print("\033[31;1mmember [%s] is dead!\033[0m" % self.name)


class Teacher(SchoolMember):
    def __init__(self, name, age, course, salary):
        # SchoolMember.__init__(self, name, age)
        super(Teacher, self).__init__(name, age)    # 與上面一樣候味，在子類中重構(gòu)父類的方法
        self.course = course
        self.salary = salary
        self.enroll()

    def teaching(self):
        '''講課方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" % (self.name, self.course, 's12'))

    def tell(self):
        '''自我介紹方法'''
        msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' % (self.name, 'Oldboy', self.course)
        print(msg)


class Student(SchoolMember):
    def __init__(self, name, age, grade, sid):
        super(Student, self).__init__(name, age)
        self.grade = grade
        self.sid = sid
        self.enroll()

    def tell(self):
        '''自我介紹方法'''
        msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' % (self.name, self.grade, 'Oldboy')
        print(msg)


if __name__ == '__main__':
    t1 = Teacher("Alex", 22, 'Python', 20000)
    t2 = Teacher("TengLan", 29, 'Linux', 3000)

    s1 = Student("Qinghua", 24, "Python S12", 1483)
    s2 = Student("SanJiang", 26, "Python S12", 1484)

    t1.teaching()
    t2.teaching()
    t1.tell()

• 繼承策略：
  D繼承BC刃唤；B、C繼承A
  1.廣度優(yōu)先（Python3 默認(rèn)繼承方式）：D - B - C - A
  2.深度優(yōu)先（Python2 經(jīng)典類按深度優(yōu)先白群，新式類按廣度優(yōu)先）: D - B - A尚胞，D - C - A

  
  
  廣度優(yōu)先
• 繼承

class A(object):    # class A:  經(jīng)典類
    def __init__(self):
        print("A")


class B(A):
    def __init__(self):
        print("B")


class C(A):
    def __init__(self):
        print("C")

class D(B,C):
    pass

D()  # B

• 多態(tài)：為了實(shí)現(xiàn)接口的重用，一個(gè)接口川抡，多種實(shí)現(xiàn)

# Author:Gatling
class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")


class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)


class Dog(Animal):
    def talk(self):
        print('%s: 汪辐真！汪须尚！汪！' % self.name)


def func(obj):  # 一個(gè)接口侍咱，多種形態(tài)
    obj.talk()


c1 = Cat('小晴')
d1 = Dog('李磊')

func(c1)
func(d1)

2018-02-03

XML 模塊

• http://www.cnblogs.com/alex3714/articles/5161349.html
• 讀

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)

# 遍歷xml文檔
for child in root:
    print(child.tag, child.attrib)
    for i in child:
        print(i.tag, i.text)

# 只遍歷year 節(jié)點(diǎn)
for node in root.iter('year'):
    print(node.tag, node.text)

• 修改 + 刪除

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):    # 找到 year
    new_year = int(node.text) + 1
    node.text = str(new_year)
    node.set("updated","yes")    # 添加屬性
 
tree.write("xmltest.xml")
 
 
#刪除node
for country in root.findall('country'):      # 找到所有的 country
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)    # 刪除 node
 
tree.write('output.xml')

• 查找

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")    # Element 根節(jié)點(diǎn)
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})    # SubElement 子節(jié)點(diǎn)
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml)  # 生成文檔對(duì)象
et.write("test.xml", encoding="utf-8",xml_declaration=True)  # xml_declaration 聲明這是 xml 格式的
 
ET.dump(new_xml) # 打印生成的格式

ConfigParser 模塊：解析配置文件

• 見 http://www.cnblogs.com/alex3714/articles/5161349.html

hashlib 模塊：加密相關(guān)

hmac 模塊：加密進(jìn)階版

tips

• ctrl+shift+n 查找文件
• ctrl+n

re 模塊：正則

'.'     默認(rèn)匹配除\n之外的任意一個(gè)字符耐床，若指定flag DOTALL,則匹配任意字符，包括換行
'^'     匹配字符開頭楔脯，若指定flags MULTILINE,這種也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符結(jié)尾撩轰，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*號(hào)前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  結(jié)果為['abb', 'ab', 'a']
'+'     匹配前一個(gè)字符1次或多次昧廷，re.findall("ab+","ab+cd+abb+bba") 結(jié)果['ab', 'abb']
'?'     匹配前一個(gè)字符1次或0次
'{m}'   匹配前一個(gè)字符m次
'{n,m}' 匹配前一個(gè)字符n到m次堪嫂，re.findall("ab{1,3}","abb abc abbcbbb") 結(jié)果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 結(jié)果'ABC'
'(...)' 分組匹配木柬，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 結(jié)果 abcabca456c
 
 
'\A'    只從字符開頭匹配皆串，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符結(jié)尾，同$
'\d'    匹配數(shù)字0-9
'\D'    匹配非數(shù)字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符眉枕、\t恶复、\n、\r , re.search("\s+","ab\tc1\n3").group() 結(jié)果 '\t'

• '(?P<name>...)' 分組匹配 ：配合 groupdict() 實(shí)現(xiàn)為匹配的字符加上 key 鍵

re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 
# 結(jié)果
{'province': '3714', 'city': '81', 'birthday': '1993'}

• 一些常用的方法
  re.match 從頭開始匹配（只匹配第一個(gè)）
  re.search 匹配包含（只匹配第一個(gè)）
  re.findall 把所有匹配到的字符放到以列表中的元素返回 速挑，匹配不到是空數(shù)組 [] , ['']是匹配到了
  re.split 以匹配到的字符當(dāng)做列表分隔符

>>> re.split("\d+","a1b22c333d4444e")
['a', 'b', 'c', 'd', 'e']

>>> re.split("\d","a1b22c333d4444e")
['a', 'b', '', 'c', '', '', 'd', '', '', '', 'e']

re.sub 匹配字符并替換

• res = re.match()
  res.group()：匹配到的字符串

2018-02-02

標(biāo)準(zhǔn)庫 - shutil 模塊

# Author:Freeman
import shutil

# f1 = open('note', encoding="utf-8")  # 有這個(gè)文件
# f2 = open('note2', 'w', encoding='utf-8')  # 沒有這個(gè)文件,創(chuàng)建一個(gè)
# shutil.copyfileobj(f1, f2)  # 把 f1 的內(nèi)容復(fù)制一份到 f2

shutil.copyfile('note2', 'note3')  # 直接復(fù)制一個(gè)文件的副本(note3)
# shutil.copystat(src, dst)  # 拷貝:mode bits,atime,mtime,flags
# shutil.copy()  # 拷貝文件和權(quán)限
# shutil.copy2()  # 拷貝文件和狀態(tài)信息
# shutil.copytree(原目錄,目標(biāo)目錄) # 完整的拷貝目錄
# shutil.rmtree()   # 刪除目錄
# shutil.move()  # 移動(dòng)文件
# shutil.make_archive("壓縮", 'zip', r'D:\ForPython\2018-1-30')  # 創(chuàng)建壓縮包并返回路徑

shelve 模塊

2018-02-01

標(biāo)準(zhǔn)庫 - random

import random
random.randint(1,10)    # 隨機(jī)  [1,10] 的整數(shù)
random.randrange(1,10)    # 隨機(jī) (1,10) 的整數(shù)
random.choice(seq)  

標(biāo)準(zhǔn)庫 - os

• 常用方法

# Author:Freeman
import os

print(os.getcwd())  # 當(dāng)前路徑:D:\ForPython\2018-02-01
os.chdir(r"D:\ForPython\2018-02-01")  # 切換路徑:命令行中為了避免轉(zhuǎn)義,需要兩個(gè)\\ ,也可以 r'D:\ForPython'
print(os.getcwd())  # D:\ForPython
print(os.curdir)  # 當(dāng)前目錄   .
print(os.pardir)  # 上一級(jí)目錄   ..
os.makedirs(r'a\b\c')  # 遞歸創(chuàng)建目錄(可以指定任意路徑)
os.removedirs(r'a\b\c')  # 遞歸刪除目錄
# 刪除目錄(主要用于清理空目錄)：
# 1.檢查c是否為空谤牡，是則刪除c
# 2.檢查b是否為空，是則刪除b
# 3.檢查a是否為空姥宝，是則刪除a
os.mkdir(r"E:\abc")  # 創(chuàng)建目錄(可以指定任意路徑)
os.rmdir(r"E:\abc")  # 刪除單個(gè)目錄
print(os.listdir())  # 返回當(dāng)前目錄下的文件組成的一個(gè) list(包括隱藏文件)
# os.rename(r'D:\ForPython\2018-02-01\level2_change', r'D:\ForPython\2018-1-31\level2')  # 把參數(shù)1的文件轉(zhuǎn)移到參數(shù)2,支持改名
os.stat("os.py") # 獲取文件 / 目錄信息
os.environ # 查看環(huán)境變量
os.name # 當(dāng)前系統(tǒng)名
os.path.abspath()
os.path.split(r"D:\a\b\c\d.txt")  # 返回：('D:\a\b\c','d.txt')  (不考慮文件是否存在)
os.path.basename(r"D:\a\b\c.txt")  # 返回：'c.txt'  (不考慮文件是否存在)
os.path.exists()  # 判斷路徑是否存在
os.path.isabs()  # 是否為絕對(duì)路徑(Windows 以盤符開始翅萤，Linux以 / 開始)
os.path.isfile()  # 是否為一個(gè)文件
os.path.isdir()  # 是否為一個(gè)目錄
os.path.join(r'C:',r'\a.txt')  # 'C:\a.txt'
os.path.getatime()  # 文件或目錄的最后存取時(shí)間
os.path.getmtime()  # 文件或目錄的最后修改時(shí)間

• 特別說明：由于 Windows 和 Linux 操作系統(tǒng)的路徑規(guī)范不一致，

Windows 系統(tǒng)下(Linux 對(duì)應(yīng)表格)

• os.system(command)

  
  
  os.system()

標(biāo)準(zhǔn)庫 - sys 模塊

tips

折疊面板和自帶命令行

2018-1-31

標(biāo)準(zhǔn)庫 - time 模塊

• 忘了有什么方法可以使用 help()
• 時(shí)間戳 / Structure_time(tuple 格式) / 格式化字符串
  1.時(shí)間戳 => 元祖 localtime()腊满，gmtime()
  2.元祖 => 時(shí)間戳 mktime()
  3.元祖 => 指定字符串時(shí)間格式 strftime()
  4.指定字符串時(shí)間格式 => 元祖 strptime()
  5.時(shí)間戳=>字符串 asctime([tuple])套么，ctime([seconds])

# time 具有的方法
time() -- return current time in seconds since the Epoch as a float
clock() -- return CPU time since process start as a float
sleep() -- delay for a number of seconds given as a float
gmtime() -- convert seconds since Epoch to UTC tuple
localtime() -- convert seconds since Epoch to local time tuple
asctime() -- convert time tuple to string
ctime() -- convert time in seconds to string
mktime() -- convert local time tuple to seconds since Epoch
strftime() -- convert time tuple to string according to format specification
strptime() -- parse string to time tuple according to format specification
tzset() -- change the local timezone

• 時(shí)間戳格式化為指定格式

# Author:Freeman
import time

Epoch_time = time.time()
time_tuple = time.localtime(Epoch_time)
format_time = time.strftime("%Y-%m-%d %H:%M:%S", time_tuple)  # %Y 不是位置對(duì)應(yīng)，%Y 放哪里都是年

print(Epoch_time)
print(time_tuple)
print(format_time)

# 1517414160.0117865
# time.struct_time(tm_year=2018, tm_mon=1, tm_mday=31, tm_hour=23, tm_min=56, tm_sec=0, tm_wday=2, tm_yday=31, tm_isdst=0)
# 2018-01-31 23:56:00

• 時(shí)間格式的符號(hào)說明

%a    本地（locale）簡(jiǎn)化星期名稱    
%A    本地完整星期名稱    
%b    本地簡(jiǎn)化月份名稱    
%B    本地完整月份名稱    
%c    本地相應(yīng)的日期和時(shí)間表示    
%d    一個(gè)月中的第幾天（01 - 31）    
%H    一天中的第幾個(gè)小時(shí)（24小時(shí)制糜烹，00 - 23）    
%I    第幾個(gè)小時(shí)（12小時(shí)制违诗，01 - 12）    
%j    一年中的第幾天（001 - 366）    
%m    月份（01 - 12）    
%M    分鐘數(shù)（00 - 59）    
%p    本地am或者pm的相應(yīng)符    一    
%S    秒（01 - 61）    二    
%U    一年中的星期數(shù)。（00 - 53星期天是一個(gè)星期的開始疮蹦。）第一個(gè)星期天之前的所有天數(shù)都放在第0周。    三    
%w    一個(gè)星期中的第幾天（0 - 6茸炒，0是星期天）    三    
%W    和%U基本相同愕乎，不同的是%W以星期一為一個(gè)星期的開始。    
%x    本地相應(yīng)日期    
%X    本地相應(yīng)時(shí)間    
%y    去掉世紀(jì)的年份（00 - 99）    
%Y    完整的年份    
%Z    時(shí)區(qū)的名字（如果不存在為空字符）    
%%    ‘%’字符

標(biāo)準(zhǔn)庫 - datetime 模塊

# Author:Freeman
import datetime

_now = datetime.datetime.now()
_future_day = datetime.datetime.now() + datetime.timedelta(3)
_ago_day = datetime.datetime.now() + datetime.timedelta(-3)
_future_hours = datetime.datetime.now() + datetime.timedelta(hours=3)
_future_minutes = datetime.datetime.now() + datetime.timedelta(minutes=15)
_ago_minutes = datetime.datetime.now() + datetime.timedelta(minutes=-15)

print(_now)                  # 2018-02-01 00:32:21.502319
print(_future_day)           # 2018-02-04 00:32:21.502319
print(_ago_day)              # 2018-01-29 00:32:21.502319
print(_future_hours)         # 2018-02-01 03:32:21.502319
print(_future_minutes)       # 2018-02-01 00:47:21.502319
print(_ago_minutes)          # 2018-02-01 00:17:21.502319

關(guān)于導(dǎo)入包

• 導(dǎo)入包實(shí)際上是導(dǎo)入包內(nèi)的 __init__.py 文件壁公，因此需要在 __init__.py 中進(jìn)一步導(dǎo)入子包或模塊
  
  目錄結(jié)構(gòu)
  
  現(xiàn)在想為 grandpa.py 導(dǎo)入 son.py感论，步驟如下：

# grandpa.py
import level2

# level2 包內(nèi)的 __init.py__
from . import level3

# level3  包內(nèi)的 __init.py__
from . import son

# son.py 
text = "調(diào)用成功!"

# grandpa.py 中調(diào)用 son 中的方法
print(level2.level3.son.text)      # 調(diào)用成功!

tips

• Structure 界面可以顯示當(dāng)前文件的變量和函數(shù)，打開方法：
  1.alt+7
  2.view - Tool Windows - Structure

  
  
  Structure

• 在 Project 視圖中紊册，讓文件顯示包括的方法

  
  
  Show Members
• import module_A 再通過 module_A.func 調(diào)用模塊內(nèi)的 func 方法是先找到 module_A 再引用 func 方法比肄，如果引用 N 次 func 快耿，則在找 module_A 上會(huì)浪費(fèi)掉大量的時(shí)間，因此針對(duì)這種情況芳绩，如果只引用 func 方法掀亥，則使用 from module_A import func 會(huì)減少找文件的時(shí)間

2018-1-30

模塊

• 定義：本質(zhì)就是 .py 結(jié)尾的 Python 文件，目的就是為了實(shí)現(xiàn)某個(gè)功能（文件名為
  test.py 則模塊名為 test）
• 導(dǎo)入模塊方法

# 第一種導(dǎo)入
import module1,module2    # 導(dǎo)入多個(gè)模塊
module1.func()            # 調(diào)用

# 第二種導(dǎo)入
from module import func        # 導(dǎo)入所有變量和函數(shù)（不建議妥色，重名）
from module import func1,func2,func3
func()                          # 調(diào)用 不能 module1.func()搪花，因?yàn)閷?dǎo)入的是模塊里的所有內(nèi)容

# 第三種導(dǎo)入
from module import func as another_func      #  起個(gè)別名
another_func()                               # 調(diào)用

# 第四種導(dǎo)入
from . import func                 #  從當(dāng)前目錄下導(dǎo)入 func

• import 本質(zhì)：相當(dāng)于把 A模塊內(nèi)所有的代碼統(tǒng)一賦給變量 A
• from module import func：相當(dāng)于直接把 module 中的 func 代碼賦給一個(gè) func 變量
• 包的定義：從邏輯上組織模塊，本質(zhì)就是一個(gè)目錄（必須帶有一個(gè) init.py 的文件）
• 導(dǎo)入包文件實(shí)際上就是執(zhí)行包內(nèi)的 __init__.py 文件（只是當(dāng)前包內(nèi)的__init__py）
  
  導(dǎo)入包

2018-1-28

Python 內(nèi)置方法

• abs()： 絕對(duì)值
• all()：全真反真

# Author:Freeman
list = [0, 1, 2, 3]
print(all(list))     # True

• any()：有真反真
• ascii()：
• bin()：十進(jìn)制整數(shù)轉(zhuǎn)二進(jìn)制
• bool()：布爾值
• bytearray()：返回 ascii 碼嘹害，并且可通過為元素賦不同的 ascii 碼值來改變（常規(guī)的str和二進(jìn)制是無法在原對(duì)象上改變的撮竿，都是創(chuàng)建一個(gè)副本）

# Author:Freeman
a = bytes("abcde", encoding="utf-8")
b = bytearray("abcde", encoding="utf-8")
print(a.capitalize(), a)
print(b[0])  # ascii 碼
b[0] = 98
print(b)

# b'Abcde' b'abcde'
# 97
# bytearray(b'bbcde')

• callable()：判斷是否可調(diào)用，例如函數(shù)就可通過 （）調(diào)用笔呀，list 沒法調(diào)用
• chr()：傳入 ascii 碼值幢踏，返回對(duì)應(yīng)符號(hào)
• ord()：傳入 符號(hào)，返回 ascii 值
• compile()：跟 js 的 eval 差不多
• dir(對(duì)象) 查看對(duì)象可以調(diào)用的方法
• divmod()：返回商和余數(shù)
• eval()：
• exec()：
• filter()：過濾

# Author:Freeman

express = lambda n: n > 5
res = filter(express, range(10))
print(type(res))  # <class 'filter'>
for i in res:
    print(i)

# <class 'filter'>
# 6
# 7
# 8
# 9

• map()：

# Author:Freeman

express = lambda n: n * n
res = map(express, range(5))
print(type(res))  # <class 'map'>
for i in res:
    print(i)

# <class 'map'>
# 0
# 1
# 4
# 9
# 16

• reduce()：意思就是對(duì)sequence連續(xù)使用function, 如果不給出initial, 則第一次調(diào)用傳遞sequence的兩個(gè)元素, 以后把前一次調(diào)用的結(jié)果和sequence的下一個(gè)元素傳遞給function. 如果給出initial, 則第一次傳遞initial和sequence的第一個(gè)元素給function.

# Author:Freeman

import functools

express = lambda x, y: x + y
res = functools.reduce(express, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])  
# 計(jì)算過程 ((((((((0 + 1) + 2) + 3) + 4) + 5) + 6) + 7) + 8) + 9
print(res)

# 45

• lambda表達(dá)式：

lambda n:3 if n<4 else n
# n 小于 4 就是 3许师，否則就是 n

• frozenset([iterable])：不可變集合房蝉，用了之后集合就不能進(jìn)行添加刪除

• globals()：返回當(dāng)前文件內(nèi)所有的全局變量和值的 dict 格式

• locals()：返回當(dāng)前局部作用于內(nèi)的變量和值

• hash()：將參數(shù)轉(zhuǎn)換為 hash 值，為了方便排序后的 折中查找

• hex()：轉(zhuǎn)成十六進(jìn)制

• oct()：八進(jìn)制

• max()：

• min()：

• pow()：冪

• reversed()：反轉(zhuǎn)

• round()：保留幾位小數(shù)

• slice()：

• sorted()：排序

• zip()：

# Author:Freeman
key = ["a", "b", "c", "d"]
val = [9, 5, 2, 7]

for i in zip(key, val):
    print(i)

# ('a', 9)
# ('b', 5)
# ('c', 2)
# ('d', 7)

序列化（dumps） / 反序列化（loads）

• dumps / loads 操作只進(jìn)行一次枯跑，多次 dumps 的確可以存入多個(gè) json 字符串惨驶，但沒法正確 loads
• json

# Author:Freeman
import json

def sayhi():
    print("hello,", name)

jsonObj = {
    "name": "kaka",
    "age": "18",
    # "func":sayhi      # 會(huì)報(bào)錯(cuò)，不支持這種方式
}

f = open("yesterday", "r", encoding="utf-8")
# f.write(json.dumps(jsonObj))  # str
json.loads(f.read())      # dict

• pickle：是以 bytes 類型寫入或者讀取敛助，因此 open 的方式必須為 wb 或 rb 等二進(jìn)制讀寫

# Author:Freeman
import pickle


def sayhi(name):
    print("hello,", name)


pickleObj = {
    "name": "kaka",
    "age": "18",
    "func": sayhi
}

f = open("yesterday", "wb")
f.write(pickle.dumps(pickleObj))    # pickle.dump(pickleObj,f)  # 效果一樣

以上代碼存在于文件A粗卜，但在另一個(gè)文件B中去讀 yesterday 這個(gè)文件會(huì)報(bào)錯(cuò)，因?yàn)?sayhi 這個(gè)函數(shù)只是存在于文件A之中纳击，在文件B中是找不到 sayhi 的內(nèi)存地址续扔，除非在B中定義一個(gè)同名的 sayhi 函數(shù)

python 建議項(xiàng)目結(jié)構(gòu)

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

簡(jiǎn)要解釋一下:
# 
# bin/: 存放項(xiàng)目的一些可執(zhí)行文件纱昧，當(dāng)然你可以起名script/之類的也行识脆。
# foo/: 存放項(xiàng)目的所有源代碼善已。(1) 源代碼中的所有模塊换团、包都應(yīng)該放在此目錄艘包。不要置于頂層目錄的猛。(2) 其子目錄tests/存放單元測(cè)試代碼耀盗； (3) 程序的入口最好命名為main.py。
# docs/: 存放一些文檔卦尊。
# setup.py: 安裝叛拷、部署、打包的腳本猫牡。
# requirements.txt: 存放軟件依賴的外部Python包列表胡诗。
# README: 項(xiàng)目說明文件。
# 除此之外淌友，有一些方案給出了更加多的內(nèi)容煌恢。比如LICENSE.txt,ChangeLog.txt文件等，我沒有列在這里震庭，因?yàn)檫@些東西主要是項(xiàng)目開源的時(shí)候需要用到瑰抵。如果你想寫一個(gè)開源軟件，目錄該如何組織器联，可以參考這篇文章二汛。

跨文件調(diào)用

• 想從 atm.py 中調(diào)用 main.py 的方法

  
  
  項(xiàng)目結(jié)構(gòu)

# atm.py

# print(__file__) # 相對(duì)路徑, pycharm 中顯示的是絕對(duì)路徑

import sys,os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath((__file__))))

# __file__ 代表當(dāng)前文件
# os.path.abspath 絕對(duì)路徑  D:\ForPython\atm\bin\atm.py
# os.path.dirname 當(dāng)前文件所在的目錄名,這里向上找了兩次

sys.path.append(BASE_DIR)  # 添加環(huán)境變量
# sys.path 本身返回的是一個(gè)當(dāng)前文件能訪問到的路徑組成的一個(gè) list，
# 因此只要在這個(gè) list 中添加一個(gè)新模塊的路徑，在當(dāng)前文件中就可以 import 新模塊
# 這里還有個(gè)問題婿着，新插入的路徑在最后面，如果在之前有重名的模塊就不會(huì)調(diào)用到預(yù)期的模塊，但由于是 list蜗字，可以不采取 append 而是 insert 之類的方法

from conf import settings
from core import main

main.info()

# 你已經(jīng)成功調(diào)取到 main.py 的內(nèi)容！

# main.py

def info():
    print("你已經(jīng)成功調(diào)取到 main.py 的內(nèi)容楼吃！")

2018-1-27

tips

• alt + 鼠標(biāo)左鍵可以創(chuàng)建多個(gè)光標(biāo)

生成器 generator

• 為什么要使用生成器亥贸？
  比如有一個(gè)具有幾十億個(gè)元素的 list，如果想把 list 賦值給變量 a，會(huì)消耗很長(zhǎng)的時(shí)間甚纲，list 也會(huì)占用很大的內(nèi)存。generator 的存在就是為了解決這個(gè)問題，先 準(zhǔn)備 出一個(gè)具有幾十億元素的 generator （相當(dāng)于告訴內(nèi)存赴背，我要你先準(zhǔn)備一個(gè)列表乱陡，但你現(xiàn)在不用創(chuàng)建出來胳徽，等我需要用到哪個(gè)的時(shí)候再去找你适篙，到時(shí)候你只需要給我我要的東西就可以）聂儒，但并不占用內(nèi)存窜护，只有當(dāng)調(diào)用 generator 中具體某個(gè)值時(shí)，那個(gè)值才會(huì)存在于內(nèi)存之中
• generator 只有在調(diào)用的時(shí)候才生成相應(yīng)的數(shù)據(jù)，所以沒辦法使用切片或者 list 的常規(guī)操作
• generator 具有 __next__ 方法（Python3.0概行，2.7為 next()），且只能一個(gè)一個(gè)的往后找，不能返回柳恐，不能跳過

# Author:Freeman
generator = (i for i in range(10))
print(generator)
print(generator.__next__())
print(generator.__next__())

# <generator object <genexpr> at 0x000002E245B288E0>
# 0
# 1

列表生成式

• 常規(guī)

# Author:Freeman
a = [i + 2 for i in range(10)]

print(a)
# [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

• 函數(shù)

# Author:Freeman

def func(*args):
    answer = "哈哈 %s" % args
    return answer


a = [func(i) for i in range(10)]
print(a)

生成器 + 異常處理

• yield 用于保存函數(shù)的中斷狀態(tài)

# Author:Freeman
def fib(max):
    n, a, b = 0, 0, 1

    while n < max:
        yield b        # 有 yield 的存在近尚，fib 就已經(jīng)是一個(gè)生成器了，而 b 就是生成器中的元素
        a, b = b, a + b
        n = n + 1
    return "----done----"        # 用于捕獲錯(cuò)誤


g = fib(5)
# 異常捕獲
while True:
    try:
        # x = next(g)          # 在 3.0 中這句也好用
        x = g.__next__()
        print("g：", x)
    except StopIteration as e:      # 捕獲 StopIteration 錯(cuò)誤
        print("Generator return value：", e.value)
        break

# g： 1
# g： 1
# g： 2
# g： 3
# g： 5
# Generator return value： ----done----

• 生成器例子

# Author:Freeman
import time


def consumer(name):
    print("[%s]來吃包子了!" % name)
    while True:
        ab = yield
        print("[%s]包子來了,但是[%s]并沒有吃到包子" % (ab, name))


c = consumer("大飛哥")
c.__next__()  # [大飛哥]來吃包子了!
c.__next__()  # [None]包子來了,但是[大飛哥]并沒有吃到包子
c.__next__()  # [None]包子來了,但是[大飛哥]并沒有吃到包子
c.send("韭菜餡")  # [韭菜餡]包子來了,但是[大飛哥]并沒有吃到包子
c.send("面餡")  # [面餡]包子來了,但是[大飛哥]并沒有吃到包子
c.__next__()  # [None]包子來了,但是[大飛哥]并沒有吃到包子

• 生成器例子（協(xié)程）

# Author:Freeman
import time


def consumer(name):
    print("[%s]來吃包子了!" % name)
    while True:
        ab = yield
        print("[%s]包子來了,但是[%s]并沒有吃到包子" % (ab, name))


list = ["韭菜餡",  "面餡"]


def producer(name):
    c = consumer("A")
    c2 = consumer("B")
    c.__next__()
    c2.__next__()
    print("[%s]開始準(zhǔn)備做包子啦!" % name)
    for i, item in enumerate(list):
        time.sleep(1)
        print("%s做了兩個(gè)包子!"%name)
        c.send(item)
        c2.send(item)


producer("大帥哥")

# [A]來吃包子了!                          # consumer
# [B]來吃包子了!                          # consumer
# [大帥哥]開始準(zhǔn)備做包子啦!            # producer
# [大帥哥]做了兩個(gè)包子!                # producer
# [韭菜餡]包子來了,但是[A]并沒有吃到包子    # consumer
# [韭菜餡]包子來了,但是[B]并沒有吃到包子    # consumer
# [大帥哥]做了兩個(gè)包子!                # producer
# [面餡]包子來了,但是[A]并沒有吃到包子      # consumer
# [面餡]包子來了,但是[B]并沒有吃到包子      # consumer

迭代器

• 可直接作用于 for 循環(huán)的對(duì)象
  1.list 留瞳，tuple骤竹，set，dict嗤详，str
  2.generator：包括生成器和帶 yield 的 generator function
  以上兩類統(tǒng)稱為可迭代對(duì)象：Iterable，可以使用 isinstance() 判斷一個(gè)對(duì)象是否為 Iterable 對(duì)象
• 迭代器（Iterator）：可以被 next() 函數(shù)調(diào)用并不斷返回下一個(gè)值的對(duì)象
• generator 都是 Iterator 對(duì)象，但 list淋昭、dict盏檐、set 雖然是 Iterable胡野，但卻不是 Iterator豺憔，可以使用 iter() 方法將 list昼榛、dict奥喻、set 變?yōu)?Iterator

裝飾器

• 帶參數(shù)的裝飾器憎兽，不是很理解，先放這里吧

# Author:Freeman
import time

user, passwd = "kaka", "123"


def auth(auth_type):
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            if auth_type == "local":
                username = input("Username:").strip()
                password = input("Password:").strip()
                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    return func(*args, **kwargs)
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                print("搞毛線？")

        return wrapper

    return outer_wrapper


def index():
    print("welcome to index page")


@auth(auth_type="local")
def home():
    print("welcome to home page")
    return "from home"


@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs page")

# index()
# print(home())
home()
# bbs()

2018-1-26

裝飾器

• 高階函數(shù)（返回函數(shù)地址的函數(shù)）+ 嵌套函數(shù)
• 下面代碼中 timer 就是裝飾器，滿足了兩個(gè)條件：
  1.不改變 test1 的內(nèi)容；
  2.不改變 test1 的調(diào)用方式
• 裝飾器作用于緊鄰它的第一個(gè)函數(shù)

# Author:Freeman
import time


def timer(func):
    def deco():
        start_time = time.time()
        func()
        end_time = time.time()
        print("func run time is %s" % (end_time - start_time))

    return deco


@timer      # 裝飾器钦讳，之后直接調(diào)用 test1 就是攜帶裝飾器的調(diào)用潮秘，裝飾器作用于緊鄰它下面的第一個(gè)函數(shù)
def test1():
    time.sleep(2)
    print("this is test1 func")

test1()
# timer(test1)()    # 如果不用裝飾器躏精，也可以這么寫

• 如何攜帶參數(shù)？

# Author:Freeman
import time


def timer(func):
    def deco(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        end_time = time.time()
        print("func run time is %s" % (end_time - start_time))

    return deco


@timer
def test1(*args, **kwargs):
    time.sleep(2)
    print("this is test1 func:", *args, **kwargs)


# timer(test1)()
# test1 = timer(test1)  # 不要考慮那些亂七八糟的涣旨，timer 執(zhí)行返回 deco 地址霹陡，test1 就是 deco 地址，再進(jìn)一步說魁瞪，調(diào)用 test1 就是調(diào)用 deco 
test1("kaka", {"dict_key": 5})

• 為什么沒有返回值 "from home"穆律？該怎么做，為什么导俘？

# Author:Freeman
import time

user, passwd = "kaka", "123"


def auth(func):
    def wrapper(*args, **kwargs):
        username = input("Username:").strip()
        password = input("Password:").strip()
        if user == username and passwd == password:
            print("\033[32;1mUser has passed authentication\033[0m")
            func(*args, **kwargs)
        else:
            exit("\033[31;1mInvalid username or password\033[0m")

    return wrapper


def index():
    print("welcome to index page")


@auth
def home():
    print("welcome to home page")
    return "from home"        # 為什么這行沒有返回？打印結(jié)果中的 None 是哪來的泣崩？


@auth
def bbs():
    print("welcome to bbs page")


index()
print(home())
bbs()

# welcome to index page
# Username:kaka
# Password:123
# User has passed authentication
# welcome to home page
# None      # 這是什么鬼烘跺？from home 呢屁擅？
# Username:

# 解釋：
# 如上個(gè)例子所言，調(diào)用 home 就等于調(diào)用 wrapper
# 然而 home 有返回值盗忱，裝飾器中 wrapper 中的 home() 也的確進(jìn)行了調(diào)用并返回了 from home，但是 wrapper 沒有 return
# 可以理解為 wrapper 中已經(jīng)包含了 home 的返回值 from home 啃擦，但是 wrapper 沒有把 這個(gè) from home 的結(jié)果 return 出來
# 沒有 return 語句的函數(shù)默認(rèn)返回值為 None
# 注意：return wrapper 是 auth 的返回值兔乞，不是 wrapper 的

2018-1-25

tips

• y=x=1强品，1一直在內(nèi)存中，可以通過x，y來找到1的內(nèi)存地址。使用 del 可以刪除 x宦言，y 而1不會(huì)被 del 刪除谅河，當(dāng) 1 沒有任何引用的時(shí)候胰伍，Python 內(nèi)部的定時(shí)回收機(jī)制會(huì)刪除 1

裝飾器

• 定義：本質(zhì)是函數(shù)自脯，用于裝飾其它函數(shù)——為其它函數(shù)添加附加功能
• 原則：
  1.不能修改被裝飾函數(shù)的源代碼
  2.不能修改被裝飾函數(shù)的調(diào)用方式
• 通俗的講，裝飾器可以讓函數(shù)在不知情的情況下發(fā)生改變
• 實(shí)現(xiàn)裝飾器的知識(shí)儲(chǔ)備：
  1.函數(shù)即是變量
  2.高階函數(shù)：a.把函數(shù)名當(dāng)做一個(gè)實(shí)參傳給另一個(gè)函數(shù)；b.返回值中包含函數(shù)名
  3.嵌套函數(shù)
  高階函數(shù)+嵌套函數(shù) => 裝飾器

2018-1-24

• int 是 向0取整

遞歸

• 必須要有一個(gè)明確的結(jié)束條件
• 每次進(jìn)入更深一層的遞歸時(shí)，問題的規(guī)模相比上一次遞歸都應(yīng)該有所減少
• 遞歸效率不高杯活，遞歸次數(shù)過多會(huì)導(dǎo)致棧溢出
• 做遞歸用 斷點(diǎn) 調(diào)試

函數(shù)

• 默認(rèn)參數(shù)

# Author:Freeman
def func(x, y, z=3):
    print(x)
    print(y)
    print(z)

func(2, 1, "kk")
# 輸出 2,1,kk

• 非固定參數(shù) * + 形參或衡，*args 接收 位置參數(shù) 轉(zhuǎn)換成 元祖

# Author:Freeman
def func(*args):
    print(args)
    print(args[1])
    print(len(args))


func(2, 1, "kk")
# (2, 1, 'kk')
# 1
# 3

# Author:Freeman
def dict(name, age=12, *args):
    print(name)
    print(age)
    print(args)


dict(*["lky", "222", "gogogo"])
# lky
# 222
# ('gogogo',)

• 接受字典參數(shù) ** + 形參焦影，兩種方式傳參，**kwargs 部分只能接收 關(guān)鍵字參數(shù)(a=3 這種) 轉(zhuǎn)換成 字典

# Author:Freeman
def dict(**kwargs):
    print(kwargs)

dict(name="xxx", age="123", salary="沒有")                  # 第一種
dict(**{"name" : "xxx", "age" : "123", "salary" : "沒有"})  # 第二種
# {'name': 'xxx', 'age': '123', 'salary': '沒有'}    
# {'name': 'xxx', 'age': '123', 'salary': '沒有'}

**kwargs 參數(shù)組往后放：當(dāng)關(guān)鍵字參數(shù)合法時(shí)封断，不會(huì)被當(dāng)做字典參數(shù)

# Author:Freeman
def dict(name, age=12, **kwargs):
    print(name)
    print(age)
    print(kwargs)

dict(name="lky",age="222",key="gogogo")
# lky
# 222
# {'key': 'gogogo'}

• 在局部作用域修改全局變量：global 斯辰。避免使用 global 在局部作用于聲明全局變量

# Author:Freeman
abc = 12

def change(param=3):
    global abc  # 這里不能寫賦值
    abc = 11
    print(abc)  # 這里不能寫賦值

change()
# 11

2018-1-23

編程方式

• 面向?qū)ο?br> 核心是 類，定義它的關(guān)鍵字就是 class
• 面向過程
  過程坡疼，def：實(shí)際上就是沒有返回值的函數(shù)彬呻，Python 解釋器隱式的返回 None。而面向過程的編程方式實(shí)際上就是用許多沒有返回值的函數(shù)組成的一種編程方式柄瑰。
• 函數(shù)式編程
  函數(shù)闸氮， def：有返回值

函數(shù)

• 直接傳參 / 位置調(diào)用
• 位置調(diào)用需要與形參一一對(duì)應(yīng)
• 位置調(diào)用與關(guān)鍵字調(diào)用混用時(shí)，應(yīng)保證位置參數(shù)在前教沾，最好別這么混著用

# Author:Freeman
def func(x, y):
    print(x)
    print(y)

# func(1, 2)
func(y=1, x=2)

輸出時(shí)間

# Author:Freeman
import time

rule = "%Y-%m-%d %X"
time = time.strftime(rule)
print(time)
# 輸出  2018-01-23 23:08:23

2018-1-22

打印系統(tǒng)默認(rèn)編碼

• sys.getdefaultcoding()

ASCII Unicode utf-8 的區(qū)別

• 不同國家的編碼互相轉(zhuǎn)換都需要先轉(zhuǎn)換成 Unicode：比如中國的GBK編碼蒲跨，需要先解碼為 Unicode 再編碼成其他國家的編碼
  有個(gè)圖不錯(cuò)，去找一下

with

• 無需再寫關(guān)閉文件語句授翻，with 語句執(zhí)行完后文件就被關(guān)閉
• Python2.7 之后 with 語句可以打開多個(gè)文件
• Python 官方書寫規(guī)范或悲，通過 反斜杠 \ 換行

# Author:Freeman
import sys

with open("yesterday", "r", encoding="utf-8") as f, \
        open("yesterday2", "r", encoding="utf-8") as f2:
    for i in f:
        print(i.strip())

tips

• 為什么需要在代碼中關(guān)閉文件？
  盡管在你關(guān)閉程序時(shí)堪唐，Python 的垃圾回收機(jī)制會(huì)自動(dòng)收回打開文件所占用的內(nèi)存巡语，但如果你打開N多個(gè)文件，如果不通過代碼關(guān)閉文件的占用淮菠，則這個(gè)文件會(huì)一直占用內(nèi)存男公。

sys.argv

• sys.argv：

# Author:Freeman
import sys

item = sys.argv
print(item)
print(item[0])
print(item[1])
print(item[2:])

需要在命令行下

• 一個(gè)查找并替換文件內(nèi)容的方法

# Author:Freeman
import sys

f = open("yesterday", "r+", encoding="utf-8")

old_str = sys.argv[1]
new_str = sys.argv[2]

for line in f:
    if old_str in line:
        line = line.replace(old_str, new_str)
        print(line)

yesterday 文件的內(nèi)容

命令行中執(zhí)行結(jié)果

之前的

快捷鍵

• ctrl + alt + L 代碼格式化
• ctrl + B 跳轉(zhuǎn)到源代碼 或者 按住 ctrl+左鍵
• ctrl + w 逐漸擴(kuò)選代碼塊，ctrl + shift + w 反之
• ctrl + / - 展開 / 折疊代碼 合陵，加 shift 就是全部展開 / 折疊

input()

• 導(dǎo)入模塊理澎，getpass 在 pycharm 中不好使
• input("123") 中輸入的結(jié)果會(huì)被當(dāng)做 字符串逞力，轉(zhuǎn)換為數(shù)字需要 int(input("123"))

# Author:Liu
import getpass

_username = "lky"
_password = "123"
username = input("name:")
password = getpass.getpass("password:")

if _username == username and _password == password:
    print("Welcome {name} login".format(name=username))    # 字符串連接
else:
    print("Invalid username or password")

循環(huán) 判斷 跳出循環(huán)

• while，for 都可以搭配 else

# Author:Liu

age_of_oldboy = 56

while True:
    guess_age = int(input("guess age:"))
    if guess_age == age_of_oldboy:
        print("yes ,you got it.")
        break
    elif guess_age > age_of_oldboy:
        print("think smaller...")
    else:
        print("think bigger!")

range()

• range(開始,結(jié)束,步長(zhǎng))

# Author:Liu
for i in range(1, 10, 3):
    print(i)      # 1,4,7

打斷點(diǎn)

image.png

模塊（庫）

• 標(biāo)準(zhǔn)庫：直接可用糠爬，比如 getpass

• 第三方庫：例如 Django

• 文件名避免與庫名重復(fù)

• sys 模塊
  1.sys.path：環(huán)境變量
  2.sys.argv：當(dāng)前腳本的相對(duì)路徑（Pycharm 中由于軟件設(shè)置寇荧，會(huì)打印絕對(duì)路徑）

  
  
  sys 模塊（site-packages 為第三方庫存放地址，lib 層為標(biāo)準(zhǔn)庫存放地址）

• os 模塊：一般用于與系統(tǒng)的交互
  1.os.system("dir")：用于直接顯示當(dāng)前文件所在目錄的所有文件执隧，之后返回結(jié)果揩抡，0 代表成功

  
  
  os.system("dir")

# 一些常用的 os 方法
# Author:Liu
import os

# cmd_res = os.system("dir")  # 執(zhí)行命令,無法保存結(jié)果
# cmd_res = os.popen("dir")   # 內(nèi)存對(duì)象地址
# cmd_res = os.popen("dir").read()   # 讀取地址
os.mkdir("new_dir_by_python")      # 創(chuàng)建目錄
print("-->", cmd_res)

.pyc 是什么？

• .pyc 文件是 Python 的編譯后的 字節(jié)碼文件镀琉，它還不是機(jī)器碼峦嗤，甚至算不上 “半成品”
• 程序第一次運(yùn)行后產(chǎn)生 .pyc 文件，下次再運(yùn)行時(shí)就不需要重新編譯屋摔，直接調(diào)用 .pyc 文件
• 當(dāng)保存了 .pyc 文件之后烁设，對(duì)源文件又做了改動(dòng)，這時(shí) Python 會(huì)根據(jù)源文件和 .pyc 文件的最后更新時(shí)間來判斷文件是否經(jīng)過改動(dòng)

數(shù)據(jù)類型

• type() 查看數(shù)據(jù)類型
• ** 冪
• int 整形 钓试，long 長(zhǎng)整型装黑，float 浮點(diǎn)型，布爾弓熏，字符串恋谭，bytes 類型
• 視頻，音頻的二進(jìn)制傳輸類型為 bytes
• python3 沒有長(zhǎng)整形 long

三元運(yùn)算

result = 值1 if 條件1 else 條件2

十六進(jìn)制表示法

• 0x 前綴挽鞠，或者 H 作為后綴

編碼和解碼

• 需要編碼.encode(想要轉(zhuǎn)換成那種編碼)
• 需要解碼.decode(之前的編碼集)
• Python3 中 encode() 之后都會(huì)變成 bytes 類型
• 所有的 .decode() 動(dòng)作都是要解碼為 Unicode

切片

• 切片也可以跳著切疚颊，[起點(diǎn):終點(diǎn):步長(zhǎng)]

# Author:Liu
names = ["a", "b", "c", "d"]
print(names[0])
print(names[1:2])
print(names[1:])
print(names[-2:])
names.insert[1,"abc"]      # 插入
names[2] = "aaaa"          # 替換
del names[1]               # 刪除    也可以刪除變量
names["c"]                 # 刪除

切片

• append()：最后添加
• pop([index])：刪除，不寫參數(shù)默認(rèn)刪除最后一個(gè)
• insert(位置信认，需要插入的元素)
• index("xxx") 位置
• count("xxx") 數(shù)量
• list.clear() 清空
• copy() 淺拷貝材义，只復(fù)制第一層，是復(fù)制嫁赏，復(fù)制完就變成兩個(gè)獨(dú)立的 第一層母截！

# Author:Liu
import copy

names = ["name", ["saving"]]
# 淺copy的三種方式
names2 = copy.copy(names)
names2 = names[:]
names2 = list(names)
# 淺copy的用途 —— 聯(lián)合賬號(hào)
names[0] = "husband"
names2[0] = "wife"
names[1][0] = 5000

print(names)        #['husband', [5000]]
print(names2)       #['wife', [5000]]

• 深拷貝：將數(shù)據(jù)完全拷貝一份，互不影響橄教，沒有引用問題

# Author:Liu
import copy
# 深copy
names = ["a", "b", "b", [1, 2], "c", "d"]
names2 = copy.deepcopy(names)
names2[3][1] = "bbbbb"
print(names[3][1])

元祖（只讀列表）

• 不能改的列表
• 只有兩個(gè)方法，count()喘漏，index()

.isdigital()

• .isdigital()：純整數(shù) 的字符串护蝶，返回：true，false翩迈。

enumerate()

• for index,item in enumerate(list) 跟 jQuery 的 each 循環(huán)差不多

字符串操作持灰，注意，是字符串的方法

• capitalize()：首字母大寫
• count()：計(jì)數(shù)
• center()：一共 xx 個(gè)字符负饲，不夠的話用指定字符填充堤魁，如果是兩邊不對(duì)等喂链，字符串右側(cè)多一個(gè)

# Author:Liu
name = "123"
print(name.center(40, "-"))
# ------------------123-------------------

• encode()
• endswith()：字符串以什么結(jié)尾
• expendtabs()：當(dāng)字符串中有 \t 時(shí)，可在方法內(nèi)添加 tabsize=12 來替換字符串中的 \t
• find()：返回查詢字符串的第一個(gè)字符的位置
• format()：格式化嵌入數(shù)據(jù)
• format_map()：參數(shù)傳一個(gè) 字典

# Author:Liu
name = "My name is {name},I'm {age} years old"
print(name.format(name="kaka", age='2222'))
print(name.format_map({"name":"Dictionary","age":"122"}))
# My name is kaka,I'm 2222 years old
# My name is Dictionary,I'm 122 years old

• index()：下標(biāo)
• inalnum()：只包含數(shù)字字母的字符串才是 true 妥泉，含有其它的符號(hào)均為 false
• isalpha()：是否只包含純英文字符（無所謂大小寫）
• isdecimal()：
• isdigit()：是否整數(shù)椭微，不支持中文數(shù)字，也支持 “壹”
• isidentifier()：是否是一個(gè)合法的標(biāo)識(shí)符盲链，可以用來檢查變量名是否合法
• islower()：是否是小寫
• isnumeric()：是否整數(shù)蝇率，支持中文數(shù)字。注意跟 isdigit() 的對(duì)比
• isspace()：是否是空格刽沾，\t本慕，\n 也是 True
• istitle()：所有單詞是否首字母大寫
• isprintable()：tty file，drive file 會(huì)返回 False
• isupper()：是否大寫
• join()：print("-".join(["a","b","c"]))侧漓，拼接
• ljust() / rjust()：右側(cè)補(bǔ)位锅尘，左側(cè)補(bǔ)位，對(duì)應(yīng) center()
• lower() / upper()：變小寫 / 大寫
• lstrip() / rstrip() / strip()：去掉左邊 / 右邊 / 兩邊的空格或回車
  1.strip() 可以從兩邊開始刪除指定的字符串
  2.創(chuàng)建副本布蔗，不改變?cè)址?/li>
• maketrans()：

p = str.maketrans("abcd", "1234")  # 重復(fù)的話以最后為準(zhǔn)藤违，數(shù)量必須一樣
print("abcd".translate(p))
# 輸出：1234

• replace()：三個(gè)參數(shù)，被替換的何鸡，用于替換的纺弊，個(gè)數(shù)
• rfind()：返回匹配到的結(jié)果中，最右側(cè)的結(jié)果的位置
• split()：str 切割為 list
• splitlines()：以 \n 切割
• swapcase()：大寫變小寫骡男，小寫變大寫
• translate()：與 maketrans() 配合使用
• zfill()：不夠的話前面補(bǔ)0

字典 Dictionary

• 字典是無序的
• key 是唯一的
• 字典的方法：
  1.dict.del()：刪掉一個(gè) key淆游，也可不寫參數(shù)刪除整個(gè)字典
  2.dict.pop()：刪掉指定 key，必須寫參數(shù)
  3.dict.popitem()：隨機(jī)刪
  4.查找 dict["aaa"] 如果參數(shù) key 不存在會(huì)報(bào)錯(cuò)
  5.dict.get()：如果沒有參數(shù) key 直接返回 None
  5.key in dict：返回布爾值隔盛，python2.7 中是 dict.has_key("key") 犹菱。python3 中已刪除
  6.setdefault()：為字典添加新值，但如果添加的這個(gè) key 原本存在則不添加
  7.dict1.update(dict2)：把 dict2 添加到 dict1 吮炕，如果重復(fù)則更新腊脱，不重復(fù)則添加
  8.dict.items()：dict 轉(zhuǎn) tuple （看結(jié)果只轉(zhuǎn)了第一層）

# Author:Liu
info = {
    "aaa": "111",
    "bbb": "222",
    "ccc": "333",
    "ddd": {
        "ddd-1": 1,
        "ddd-2": 2,
        "ddd-3": 3
    }
}
print(info.items())
# 輸出：dict_items([('aaa', '111'), ('bbb', '222'), ('ccc', '333'), ('ddd', {'ddd-1': 1, 'ddd-2': 2, 'ddd-3': 3})])

9.fromkeys()：初始化一個(gè) dict

test = dict.fromkeys([6, 7,"link"], {"key": "value"})
test["link"]["key"] = "new_value"
print(test)
# 輸出 {6: {'key': 'new_value'}, 7: {'key': 'new_value'}, 'link': {'key': 'new_value'}}
# 注：有引用問題

pass

• 占位符，暫時(shí)什么也不寫龙亲，避免報(bào)錯(cuò)

集合及其方法

• 一種數(shù)據(jù)類型
• 沒有重復(fù)
• 無序

# Author:Freeman
list_1 = [1, 4, 5, 7, 3, 6, 7, 9]
list_1 = set(list_1)
print(set(list_1), type(list_1))
# 輸出：{1, 3, 4, 5, 6, 7, 9} <class 'set'>

• set() ：轉(zhuǎn)換為集合
• intersection()：取交集
• union()：取并集
• difference()：差集
• issubset()：判斷是否是子集
• isuperset()：判斷是否為父集
• symmetric_difference()：A與B 的交集C陕凹，（A - C）并（B - C）
• isdisjoint()：是否有交集
• & | - ^：交 并 差 對(duì)稱差
• add()：添加一項(xiàng) set.add(42)
• update()：添加多項(xiàng) set.update([1,5,3,6])
• remove()：
• len(s)：長(zhǎng)度
• in / not in ：判斷是否在其中
• pop()：刪除并返回刪除的東西
• discard()：刪除，不返回任何東西

文件操作

• open() 打開文件
• read() 讀文件
• encoding="utf-8" 用 utf-8 編碼格式打開（否則會(huì)報(bào)錯(cuò)或亂碼）鳄炉，國內(nèi) windows 默認(rèn)為 GBK 編碼

data = open("yesterday",encoding="utf-8").read()
print(data)

• 文件對(duì)象

 f = open(xxx,encoding="utf-8") # 文件句柄杜耙，這里指向文件的內(nèi)存地址

# Author:Freeman
f = open("yesterday","r", encoding="utf-8")  # r 讀 w 寫，不寫為默認(rèn) r
data = f.read()
print(data) # print(f.read())  不報(bào)錯(cuò)但也不出結(jié)果

• 文件的模式
  1.w 為重新創(chuàng)建（原來的就沒了）拂盯，重新創(chuàng)建了一個(gè)名為 xxx 的文件
  2.r 為只讀
  3.a（append）追加 在源文件的后面追加
  4.r+ 既能讀又能寫佑女，但寫是在最后面添加
  5.w+ 寫讀模式
  6.a+ 追加讀寫
  7.rb 二進(jìn)制格式讀文件 （Python3.0里網(wǎng)絡(luò)傳輸只能用二進(jìn)制格式）
  8.wb 二進(jìn)制格式寫文件
  9.ab 二進(jìn)制格式追加文件
• readline() 讀文件的一行，加參數(shù)為第幾列
• readlines() 將文件轉(zhuǎn)換為一個(gè) list ，源文件的每一行為 list 中的一個(gè)元素
• write()：
  1.每次只寫 \n 會(huì)被合并為一個(gè)
  2.如果寫完之后团驱，通過 seek() 重新定位摸吠，下次寫的時(shí)候會(huì)覆蓋而不是把之前的內(nèi)容向后推
• 讀文件的最優(yōu)方式：只占一份內(nèi)存

for line in f:
    print(line.strip())

• tell()：返回文件中的 光標(biāo) 位置 1 個(gè)數(shù)字或英文字母占一個(gè)；全角數(shù)字嚎花、漢字占三個(gè)
• seek()：重新設(shè)置 光標(biāo) 位置寸痢。并不是所有類型的文件都可以移動(dòng)光標(biāo)，因此有了 seekable() 方法
• encoding()：打印編碼
• flush()：比如 txt 文件贩幻，通常是存儲(chǔ)在硬盤上轿腺，但為了保證速度，許多時(shí)候都是在緩存中進(jìn)行操作丛楚，flush() 方法是強(qiáng)制刷新族壳，比如涉及錢時(shí)必須保證寫了多少立刻存起來，防止突然斷電
• 一個(gè)進(jìn)度效果

# Author:Freeman
import sys, time

for i in range(10):
    sys.stdout.write("#")
    sys.stdout.flush()
    time.sleep(.5)

• truncate()：無視 seek() 定位的光標(biāo)趣些，當(dāng) open 的文件為 a 時(shí)仿荆，從文件開始截取制定數(shù)量的字符，不寫參數(shù)默認(rèn)全部截取