文章目录
基础语法
编码
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()会认为子类是一种父类类型。
运算符
- 算术运算符 ±*/ %(取余) //(向下取整)
- 比较运算符 == !=(不等) <> <= >=
- 赋值运算符 = 算术运算符+=
- 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 :
<没有异常产生时的处理语句>]