小结

基础语法

编码

Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串

标识符

第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。

注释

单行 #
多行 ‘’'或""" 或多个#

缩进

python用缩进表示代码块，不需大括号{}。
缩进不一致，程序会报错 。

多行

用\n 进行换行

指令

输入指令 Input()
输出指令 print()
注：输出指令默认换行，可在末尾添加end=""实现不换行

同一行输入多条指令用；隔开。
模型运用指令：

• import module(模型)
• form module（模型） import function（函数）

数据

类型

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

赋值

用“=”，左侧为变量名，右侧为所赋值。
单变量
多变量 a=b=…= a,b,c,…=1,2,…

判断变量类型

• type()
• isinstance(被判断变量，判断类型)
  
  区别：type()不会认为子类是一种父类类型。 isinstance()会认为子类是一种父类类型。
  

运算符

1. 算术运算符 ±*/ %(取余) //(向下取整)
2. 比较运算符 == !=(不等) <> <= >=
3. 赋值运算符 = 算术运算符+=
4. python位运算符（二进制）
   5.逻辑运算符 and(与) or(或) not(非)
   6.成员运算符 in not in
   7.身份运算符 is is not
   is 与 == 区别：
   is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
   8.
   输出结果为 no
   

字符串 列表 元祖 字典等

字符串

类型

• 转义字符
  \n 换行
  \v 纵向制表符
  \t 横向制表符
  \r 回车
  \f 换页
  ‘+’ 连接
  ‘*’ 重复
  [] 索引

• 格式化字符串
  

查找

find(str, beg=0, end=len(string)) or index 用法相同，只不过如果str不在字符串中会报一个异常 ，find会显示为-1. 返回得到的值为寻找的str所在的位置。

列表

逗号分隔数据，方括号括起来

删除

del list[所删除数据位置]

指令

list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.remove(obj) 移除列表中某个值的第一个匹配项
list.sort( key=None, reverse=False) 对原列表进行排序
list.clear() 清空列表
list.copy() 复制列表

使用join链接list成为字符串
example:

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;uid=sa;database=master;pwd=secret'

分割字符串
ex:

>>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s 
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")   
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1) 
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']

元祖

与列表相似，用小括号括起来

字典

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 。

创建

遍历技巧

在字典中遍历时，关键字和对应的值可以使用 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

函数

自定义函数

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

def fun():
    import datetime
    a=datetime.date.today()
    return a
b=fun()
print(b)

>>> 
=== RESTART: C:/Users/53877/AppData/Local/Programs/Python/Python37/time.py ===
2019-08-02

参数的传递

可更改 列表 字典等
不可更改 整数 字符串等
可更改的对象，修改后，fun内外的值都相应更改
对于不可更改的，只是fun内的值改变，其本身没有变化

调用函数只需调用函数名，在函数名后输入所需参数并用（）括起来
不定长参数 声明时不会命名
def functionname([formal_args,] *var_args_tuple ): *后为元祖
运用时可赋值也可不赋值
def functionname([formal_args,] **var_args_dict ): **后为字典

匿名函数

用lambda表示
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

调用模块中函数

• 用import +文件名
  文件名+‘.’+函数名+（参数）
• 用from …import+函数名1，函数名2… 此方法只是导入函数，不会将整个模块导入
• from…import * 导入整个模块

_name_属性

如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
每个模块都有一个__name__属性，当其值是’main’时，表明该模块自身在运行，否则是被引入。
说明：name 与 main 底下是双下划线

dir()函数

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

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
点模块不用担心不同库之间模块重名

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

最简单的情况，放一个空的 :file:init.py就可以了。当然这个文件中也可以包含一些初始化代码或者为 __all__变量赋值。

导入

用户可以每次只导入一个包里面的特定模块

• 比如:
  import sound.effects.echo
  这将会导入子模块:sound.effects.echo。
  必须使用全名去访问:
  sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
• 还有一种导入子模块的方法是:
  from sound.effects import echo
  这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:
  echo.echofilter(input, output, delay=0.7, atten=4)
• 还有一种变化就是直接导入一个函数或者变量:
  from sound.effects.echo import echofilter
  同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:
  echofilter(input, output, delay=0.7, atten=4)
  import语法会首先把item当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。

输入 输出

格式美化

str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式。
rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。
还有类似的方法, 如 ljust() 和 center()。
另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

文件的读写

f=open(‘文件名’,‘r/w等’)

读
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
f.close()

写
f = open("/tmp/foo.txt", "w")
num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)
f.close()

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

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

面向对象

类（class）

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

class是关键字，表示类
创建对象，类名称后加括号即可

__两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

封装

• 封装
  self 是一个形式参数，当执行 obj1 = Foo(‘wupeiqi’, 18 ) 时，self 等于 obj1，当执行 obj2 = Foo(‘alex’, 78 ) 时，self 等于 obj2
  所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都封装了 name 和 age
• 调用
  1.直接
  通过对象直接调用被封装的内容
  上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
obj1 = Foo('wupeiqi', 18)
print obj1.name    # 直接调用obj1对象的name属性
print obj1.age     # 直接调用obj1对象的age属性
obj2 = Foo('alex', 73)
print obj2.name    # 直接调用obj2对象的name属性
print obj2.age     # 直接调用obj2对象的age属性

2.间接
执行类中的方法时，需要通过self间接调用被封装的内容

class Foo:  
    def __init__(self, name, age):
        self.name = name
        self.age = age  
    def detail(self):
        print self.name
        print self.age
   
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

继承

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('ken',10,60,3)
s.speak()
执行以上程序输出结果为:
ken 说: 我 10 岁了，我在读 3 年级

#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

类的专有方法：

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

实例中的积累

ord() 字符转ascii码
chr() ascii码转字符

提取字符串中的URL

import re
re.findall(‘https??/(?:[-\w.]|(?:%[\da-fA-F]{2}))+’, string)
findall() 查找匹配正则表达式的字符串

对ini文件的读写

模块configparser
import configparser
cf=configparser.configparser()
cf.read()
cf.add_section(’’)
cf.write(’’)

注册表的读写

winreg模块
winreg.open(key,subpath) 读取
添加
winreg.CreateKey(key,sub_key) 在key下创建一个subkey,返回值指向subkey
winreg.SetValueEx(key, value_name, reserved, type, value)
reserved=0
删减
winreg.DeleteKey(key,sub_key) 删除键
winreg.DeleteValue(key,value) 删除键值

获取文件所在目录，文件名 检索文件 遍历文件

os模块
os.chdir(path) 修改当前程序操作的路径
os.getcwd() 返回程序的当前路径
os.getlogin()返回当前系统登陆用户名称
os.name判断当前操作平台
os.listdir()返回当前目录下所有文件和目录名称

os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]
其中：

• top是要遍历的目录。
• topdown是代表要从上而下遍历还是从下往上遍历。
• onerror可以用来设置当便利出现错误的处理函数(该函数接受一个OSError的实例作为参数)，设置为空则不作处理。
• followlinks表示是否要跟随目录下的链接去继续遍历，要注意的是，os.walk不会记录已经遍历的目录，所以跟随链接遍历的话有可能一直循环调用下去。
  os.walk返回的是一个3个元素的元组 (root, dirs, files) ，分别表示遍历的路径名，该路径下的目录列表和该路径下文件列表。注意目录列表和文件列表不是具体路径，需要具体路径(从root开始的路径)的话可以用 os.path.join(root,dir) 和 os.path.join(root,dir) 。
  os.path子库
  os.path.join(path,*paths) 组合path和paths,返回一个路径字符串
  os.path.dirname(path) 返回path中的目录名称
  os.path.isfile(path)判断path是否是已经存在的文件
  os.path.isdir(path)判断path是否是已经存在的目录
  os.path.abspath(path) 返回path在当前系统中的绝对路径

运行出现错误

python 中出现的“OSError: [Errno 22] Invalid argument”
平台的bug，像pycharm，Spyder等，复制黏贴路径都会报错“OSError: [Errno 22] Invalid argument: '\u202a。。。”
修改方式为:手动输入完整路径

类中出错takes no arguments
init 前后应是双下滑线而不是单下滑线

错误<built-in method read of _io.TextIOWrapper object at 0x0023ABB0>
file = f.read() #此处漏写()导致

try except 处理异常
一般语法为：
Try:
<语句>
Except [<异常的名称> [,异常类的实例变量名称]]：
<异常处理语句>
[else :
<没有异常产生时的处理语句>]