Python

零基础掌握 Python 入门到实战笔记

内置对象类型

• 整数和浮点数
• 字符串（无单个字符）
• 列表
• 元组
• 字典
• 集合

基本交互语句

>>> a＝3

把整数对象3赋值给变量a

变量不需要指明类型

>>> b

在Python中不能单独建立变量

注意：变量引用对象，这是一个引用关系

a＝4
b＝3
a,b＝b,a

这里本质上是交换两个变量的引用关系

注意：

• 变量名可以为中文，建议是用小写英文字母
• 单词和单词之间用下划线链接
• 输入已经定义的变量返回变量引用的对象

---

常用内置函数

type(对象)#返回对象类型
int(浮点数)#取整函数（转换成整数对象）
float(对象)#浮点数转换函数（整数转换成小数））
id(对象)#查看对象所在内存空间
help(对象)#查询对象的帮助
b1 is b2#查看两个引用是否一致

注意

• 内置函数本身也是一个对象

---

整数与浮点数

不可变对象

基本数学运算

加减乘和取余大差不差（+，-，*，%）

除法支持浮点运算，可以直接得到浮点数（精确除法）

divmod(被除对象,除数)

返回：(商,余数)

取整除法：被除对象//除数

返回:商（取整结果）

round(算式,保留小数位数（四舍五入）)

不靠谱，姑且凑合着用
配合科学记数法用

科学计数法：1.2e2 = 1.2*10^2

注意：

1. 万物皆对象
2. 对象有类型
3. 变量无类型

---

高级数学运算

import math #引进math库（模块）
dir(math)   #查看math库中定义的全部函数，对象，属性
math.pi#查看math库中pi对象
math.pow(2，3)
2**3＝8#指数运算，等同于运算符**，即2^3
import decimal#引入小数库，便于小数运算
a=dicimal.Decimal('0.1')#dicimal.Decimal=创建小数对象
b=dicimal.Decimal('0.2')
a+b#交互模式下返回0.3，比round和科学计数法好用
Decimal('0.3')#返回

整数不会溢出，但是浮点数会溢出！(Python特性)

---

字符串

理解为常量字符串就可以

不可变对象

 #交互模式
ord('a')#查询a的ASCII码
bin('a')#查询a的二进制码
sys.getdefaultencoding()#查询本机的编码方式
a="python"#定义字符串
type(a)#class str(字符串)#单引号也可以定义字符串（与C语言不用）
str（）#将对象转换成字符串#防止单引号和双引号冲突，可以使用转义字符

序列

字符串=序列=对象数组

序列（对象数组）可以直接使用+连接，生成一个新的序列（与两个运算符），类似于str.cat

同时序列也可以使用运算符*，多个相同序列首尾连接生成新的序列（重复多遍）

 #交互模式
len(m)#返回序列中的字符数，对中文也使用
'p' in m#逻辑判断p是否在序列m中#正确返回True，否则返回false

索引

字符串的索引=对象数组的下标

从左到右：从0开始计数（空格也算）

从右到左：从-1开始计数

 #交互模式
m[0]==m[-len(m)]#从左到右第一位=从右到左第N位

切片

m[1:9]#读取m[1]到m[8]字符
m[1:9:2]#从m[1]读取字符对象，步长2，到m[8]为止
m[::]==m[1:len(m):1]#缺省值分别为头，尾，和步长1#步长<0表示反序

注意

字符串和int无法相加，没有自动类型转换

name=intput("展示文字")#输入
print("展示文字",name)#输出

成员函数

str.index

str.index()
'''
S.index(sub[, start[, end]]) -> intReturn the lowest index in S where substring sub is found,such that sub is contained within S[start:end].  Optionalarguments start and end are interpreted as in slice notation.Raises ValueError when the substring is not found.
'''
s="python lesson"
y="thon"
s.index('y')
>>>1s.index(y)
>>>2"python lesson".index(y)
>>>2s.index(y,4,7)
>>> ValueError: substring not found

str.split

str.split
'''
split(self, /, sep=None, maxsplit=-1)Return a list of the words in the string, using sep as the delimiter string.This list can be restored in a variable.sepThe delimiter according which to split the string.None (the default value) means split according to any whitespace,and discard empty strings from the result.maxsplitMaximum number of splits to do.-1 (the default value) means no limit.
'''a="I Love You"
a.split()
>>>['I', 'Love', 'You']lst=a.split()
lst
>>>['I', 'Love', 'You']lst=a.split("L")
lst
>>>['I ', 'ove You']a="qwertyuiopaisdfghijklzxicvbinm"
a.split('i',4)
>>>['qwertyu', 'opa', 'sdfgh', 'jklzx', 'cvbinm']
#最后一个因超出最大切分数量而保留，第二位的4是指i的个数，也可理解为只选取前4个i作为切分点

str.format

str.format
'''
S.format(*args, **kwargs) -> strReturn a formatted version of S, using substitutions from args and kwargs.The substitutions are identified by braces ('{' and '}').
'''name="I like {0} and {1}"
name.format("python","test")
>>> 'I like python and test'name="I like {1} and {0}"
name.format("python","test")
>>> 'I like test and python'
#格式化输出顺序由括号内的数字指定，与顺序无关name="I like {3} and {4}"
name.format("python","test")
>>> IndexError: Replacement index 3 out of range for positional args tuplename="I like {0:<4d} and {1:^10} and {2:>.1f}"
#第一位左对齐，最少字符长度为4，要求整数（digital）
#第二位居中对齐，最少字符长度10
#第三位右对齐，取1位小数，要求浮点数（float）
name.format(12334,"sldkfjslkdjflskjdlfkjs",12.55656456)
>>> 'I like 12334 and sldkfjslkdjflskjdlfkjs and 12.6'

注意：复数也是一个对象。

列表(List)

定义

a_lst=[2,3,3.14,"python lesson",[]]

元素特点

列表是个筐，什么都能装

• 列表元素可以重复
• 元素顺序不同则列表不同
• 列表=序列

索引和切片

a_lst[-1]
a_lst[1:3]
#a_lst[1]和a_lst[2]
a_lst[:3]
#a_lst[0],a_lst[1],a_lst[2]
a_lst[::-1]
#a_lst[-1],a_lst[-2]……a_lst[-n]
a_lst[::2]
#a_lst[0],a_lst[2]……a_lst[2n]

列表支持根据索引直接赋值，字符串不支持

例如：

a_lst[1]=100

基本操作

#支持加法
lst+lst2
#支持乘法
lst*2
#支持len
len(lst)
#支持in
a in lst

方法

一旦列表建成，元素数量无法通过索引更改

list.append()

list_append()
#简单理解为：在列表右侧增加元素，元素在括号中

注意：该方法有返回值None

list.insert()

#insert(index,object,/)
#   Insert object before index

list.extend()

#extend(self, iterable, /)
#    Extend list by appending elements from the iterable.

iterable:可迭代对象（字符串和列表）

利用可迭代对象中的元素填充列表

list.pop()

#pop(self, index=-1, /)
#    Remove and return item at index (default last).
#    Raises IndexError if list is empty or index is out of range.

• 根据索引删除元素
• 默认删除最后一个
• 返回元素

list.remove()

#remove(self, value, /)
#    Remove first occurrence of value.
#    Raises ValueError if the value is not present.

• 根据数值删除元素
• 不返回元素

list.clear()

• 清空列表元素

注意：与重建不同，clear不会影响列表的地址

a=[1,2,3]
a=[]
#抛弃旧列表，创建新的空列表，地址变更，旧列表被自动回收

list.sort()与list.rereverse()

元素类型不同会报错

• 正序和反序
• 无返回值
• 就地排序（与切片不同，切片会产生新列表）

list.copy()

列表和字符串的区别

• 列表和字符串都是序列
• 列表是容器类对象，可以根据索引变更
• 字符串不可变，但可以通过方法重建

符串与列表的转化

字符串->列表：list(str)

列表->字符串："".join(list)

字符串->列表->列表：会出错

元组(Tuple)

和列表在形状上非常类似

不可变对象

t=(1,2,"python",[1,2,3])
typle=()#空元组

与列表的区别

• 圆括号和方括号
• 创建单元素元组，需要逗号
• 元组支持序列的索引和切片
• 元组不支持根据索引修改元素
  • 可以先转换成列表在转换过来
• 属于序列，支持加法，乘法，in操作以及切片
• 元组运算速度比列表快

字典(Dict)

类型名：dict

定义

d={}#空字典
d={'name'='laoqi','age':29,'city':'soochow'}#共三个元素
d=dict(a=1,b=2,c=3)
d=dict([(a,1),(b,2),(c,3)])
d['key']='value'#如果有该键，则赋值，否则追加

• 字典元素分为两部分，“键:值”结构
• 一对键值算一个元素
• 键如果重名会保留最后一个值.
• 键只可以使用不可变对象，但值没有限制
• 根据键可以引用/修改值
• 字典不是序列，但可以使用len函数
• 使用del命令删除字典元素（使用键来指定元素）

方法

所有方法不影响物理地址

dict.get()

get(self, key, default=None, /)Return the value for key if key is in the dictionary, else default.

如果键值对存在，返回value

如果键值对不存在，则返回None，如果指定返回值，则返回之

dict.setdefault()

setdefault(self, key, default=None, /)'''Insert key with a value of default if key is not in the dictionary.Return the value for key if key is in the dictionary, else default.'''

如果键值对存在，返回value

如果键值对不存在，则把查询的key和value插入到字典中。

dict.update()

update(...)D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = vIn either case, this is followed by: for k in F:  D[k] = F[k]

参数可以为元组列表/字典

dict.pop()

pop(...)D.pop(k[,d]) -> v, remove specified key and return the corresponding value.If key is not found, default is returned if given, otherwise KeyError is raised

参数为key

如果key存在，删除key值为key的元素

若不存在，返回arg2

dict.popitem()

popitem(self, /)Remove and return a (key, value) pair as a 2-tuple.Pairs are returned in LIFO (last-in, first-out) order.Raises KeyError if the dict is empty.

删除最后一个元素

dict.copy()

dict.items()

'''
items(...)D.items() -> a set-like object providing a view on D's items
'''

• 返回所有的键值对

集合(Set)

定义

s=set(1,2,4,3,1,2)#无序性，相同元素算一个，可变集合
s=frozenset(1,2,4,3,1,2)#不可变集合
s=frozenset('qiwsir')
s={1,2,4,3,1,2}
>>> {1,2,3,4}

• 元素类型不可为可变对象

方法

set.pop()

pop(...)Remove and return an arbitrary set element.Raises KeyError if the set is empty.

• 删除并返回第一个元素

set.remove()

remove(...)Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError.

• 删除指定值
• 若不存在，则报错

set.discard()

discard(...)Remove an element from a set if it is a member.If the element is not a member, do nothing.

• 删除指定值
• 若不存在，不报错

set.copy()

各种容器类Copy函数：

list.copy()

copy(self, /)Return a shallow copy of the list.

dict.copy()

copy(...)D.copy() -> a shallow copy of D

set.copy()

copy(...)Return a shallow copy of a set.

• 都是返回该类的浅拷贝
• 浅拷贝的意思是只复制该容器中的第一层元素
• 可迭代元素只引用地址，不建立新元素

b1=['name',123,['python','php']]
b2=b1.copy()b1 is b2
>>> Falseb1[0] is b2[0]
>>> Trueb1[1] is b2[1]
>>> Trueb1[0]=100
b1[0]=b2[0]
>>> Falseb1[2][0]='test'
b1[2][0] is b2[2][0]
>>> True

换句话说，只有第一层元素复制了一份新的，可迭代元素仅复制了地址，未建立新元素

深拷贝

copy.deepcopy()

可以用该函数建立完全分离的两个副本

b3=copy.deepcopy(b1)

该引用就完全分离了

set.issuperset()

issuperset(...)Report whether this set contains another set.a.issuperset(b)#判断b是不是a的子集

set.issubset()

issubset(...)Report whether another set contains this set.a.issuperset(b)#判断a是不是b的子集

set.union()

​ 两个集合的并集

类似a | b

---

set.intersection()

​ 两个集合的交集

类似a & b

---

set.diffrence()

​ 两个集合的差集

类似a - b

注意：该运算的实质是集合A减去集合A与集合B的交集

布尔(Bool)

• 值只有True:1和False:0，可以与整数进行四则运算
• bool()可以检查对象的真假（空对象都是false）

比较运算

• 符号 >,<,==,!=,>=,<=
• is研究的是是否为同一个对象

布尔运算

注意：短路运算

• and
  • 如果A为假，返回A，如果A为真，返回B
  • A和B是对象
• or
  • 如果A为真，返回A，如果A为假，返回B
  • A和B都是对象
• not
  • 返回相反值

Python 语句

基本语句

引入模块

import math#引入math库
import math as newmath#引入math并更名
From math import function#从moudle引入函数
From math import function as new_name #从moudle引入函数并更名
From math import *#从moudle引入所以函数

赋值语句

• 基本形式：variable=object

• 衍生形式

a=1,2,3#元组
a,b,c=1,2,3#逐个赋值
a,_,c=1,2,3#用下划线占位
a,*b=1,2,3#a=1,剩下的都是b的（列表）
# 自增，自减，自乘，自除

if条件语句

总体形式：

if (<expr>):<statement><statement>
elif<statement><statement>
else<statement><following_statement>

• if 的代码块不需要使用{，}包含
• expr内容允许使用in，is等关键词
• else if –>elif

随机生成

import random
random.randint(1,10)'''randint(a, b) method of random.Random instanceReturn random integer in range [a, b], including both end points.'''

三元操作

a='python' if <expr> else "physics"

• 如果<expr>为真，则python，反之为physics

For循环语句

for <expr>:<statement>

• <expr>是循环规则不是循环条件
• 被循环只能是可迭代对象（字符串，列表，字典，元组）__iter__
• 字典循环规则下返回的是key

for i in range(100):#实现计次循环n=random.randint(1,100)lst.append(n)

常用函数

range()

'''
class range(object)|  range(stop) -> range object|  range(start, stop[, step]) -> range object|  开始，终止，步长（终止值是不会倒的）|  Return an object that produces a sequence of integers from start (inclusive)|  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.|  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.也就是说默认开始值为0|  These are exactly the valid indices for a list of 4 elements.|  When step is given, it specifies the increment (or decrement).
'''

• 返回值是range类型
• 只有当值被in用到的时候，该数值才会进入内存
• list[range(100)]，建立列表

lst=[]
for i in range(100):if i % 3 == 0:lst.append(i)

zip()

• 返回值为zip对象
• 实现两个序列一一对应的形式（以短的为准）
• 对应方式是二元元组

c=[1,2,3,4,5]
d=[5,6,7,8,9]
for x,y in zip(c,d)r2.append(x+y)
#结果是一一对应相加再组成列表元素
>>> [6,8,10,12,14]

enumerate()

• 枚举，每个元素的索引是从0开始
• 同时获取索引和数值

lst=[1,5,3,20,6,2,7]
for i,ele in enumerate(lst):if ele%2 == 0:lst[i]='even'
# i 获得索引值，ele修改数据
for i in len(lst):if lst[i]%2==0:lst[i]='even'
# i 就是索引值

列表解析

• 如果创建一个空列表，想要里面添加一些符合条件的元素的时候

[i**2 for i in range(10)]
# 1~10的平方
for i in range(10):lst.append(i**2)
# 1~10的平方
[i for i in range(100) if i%3 ==0]
# 1~100中所有3的倍数

字典解析

r={k:v for k,v in kwag.items() if dct.get(k)==v}

While循环语句

while [condition]:statements

• break,continue

Python函数

定义，框架与基本使用

• 基本形式

def function_name(x,y,z):do something return object

• 如果不写明return，默认返回None
• 函数本身也是对象，本身也保存在内存内，也有物理地址
• 函数调用：
  • 按照位置提供参数
  • 指明参数名称以及相应的值
  • 可以设置形参默认值，指定默认值的参数放在最后
• 函数返回：
  • return可以返回多个值
  • 返回多个值的时候，若接受对象为单个对象是，返回元组
• 参数收集：
  • 用一个*表示把剩余参数收集到一个元组里面
  • 用两个**表示把剩余的东西转换成字典
  • 注意注意，传参实际上是引用了对象，所以不是C里面的数值传参

嵌套函数与装饰器

嵌套定义

• 函数存在是否允许调用的问题

def function_name(function_name2):function_name2()return

• 函数嵌套调用是许可的
• 函数嵌套定义是许可的

def foo():# 定义foo函数def bar():# 定义bar函数print("I am bar")return bar# 返回bar函数
# 函数不跟括号表示该函数对象
a=foo()
a()
>>> I am bar
bar()
>>> Error#bar未定义
'''bar在foo函数作用域内，在外部环境下不可调用'''
a=1
def f3():global a#引用外部变量a=a+1print (a)

global关键字

nonlocal关键字

LEGB搜索原则

• 嵌套函数的最大特点是可以定义外部局部变量的前提下，返回一个内嵌函数
• 例如先定义g（重力加速度）然后在嵌套一个参数为质量的函数并返回，这样就可以获得一个内嵌函数

def test(g):def weight(m):return m*greturn weighta=test(10)#设定重力加速度
G=a(23)#定义质量m
G2=a(50)

装饰器

• 实际上是一种嵌套函数，外层负责标记预定义等功能，内层实现装饰工作

• 基本结构

def dec1(func):def core(name):return "{0}".format(func(name))return core
#dec1是一个包装函数，它包装形参func，返回值为core函数
#所以dec1的包装功能实际上是由core函数是实现的，dec1之于core实际上只起到了标记和传参的功能@dec1 #指明test函数的装饰器为dec1
def test(book):return "{0}".format(book)
#调用test的时候自动用dec1装饰

特殊函数

• lambda
• map
• filter

lam=lambda x:x+3
lam(2)
>>> 3
#定义简单函数#map(func,iterable)
m=map(lambda x:x+3, range(10))
list(m)
>>> [3,4,5,6,7,8,9,10,11,12]#filter过滤器
#filter(function or None,iterable)
f=filter(lambda x:x>0,range(-5,5))
list(f)
>>> [1,2,3,4,5]

Python面向对象编程

类

class CalssName:def __init__(self,name):#至少有一个参数selfself.name=name#不写return#要在这里写明所有成员变量并赋值def functionName(self):return "habby"
#调用方法接近C++
guojing=ClassName('guojing')#实例化
guojing.functionName()#调用成员函数
#注意可以直接调用成员变量

类属性

• 又称静态属性
• 只有通过类才能修改，修改后所有实例自动更新
• 类可以定义后再增加一个变量
• 实例也有类属性，但对类属性的修改只对当前对象生效

实例属性

• 类被实例化以后可以增加变量
• 该变量仅该实例拥有，类不具有
• 实例属性被删除后，会被同名类属性替代
• 在初始化方法中使用赋值
• 实例的__dict__可以查看所有实例属性（返回字典）

理解self的作用

• 类中的方法一般以self作为第一个参数
• 表示引用当前实例

类方法

对比方法和函数的不同

• 名称的命名、代码块的编写方式都一样
• 实例方法不能单独调用，只能通过实例/类调用
• 方法的第一个参数必须是self

实例方法

• 类方法以双下划线开头和结尾
• 实例方法：一般以实例的形式调用
• 初始化方法是特殊方法，该方法不可以返回不是none的值

class FOO:def method(self,x):return x*2f=FOO()
f.method(2)#以实例的形式调用方法
FOO.method(f,2)#以类的形式调用方法

class Bar:@classmethoddef method(cls,x):print(cls)@staticmethoddef add():return 'add'
#method为类方法，打印的是Bar对象
#类方法可以用雷鸣直接调用
#此处cls等同于self，原则上，在加装装饰器的情况下，cls仅作为名字存在，换什么名字都可以
#staticmethod为静态方法，不与实例绑定，可以用类名直接调用

继承

• 继承是对象的特性之一

类的继承方法

class C(P):pass #什么都没有
#C单继承P
#单继承可以方法重写（初始化方法只以子类作数）
#单继承子类初始化方法可以调用父类方法，或者使用使用（super().__init__(不用写self的剩余参数)），后者可以避免硬编码
#举例:
class P:def __init__(self,name):self.name=nameclass C(P):def __init__(self,name,age):self.age=agesuper().__init__(name)#多继承
class D(C,P):#多重继承
#注意继承顺序时的mro算法（classname.__mro__）

多态与封装

def add(x,y):return x,y
#多态的直观体现，x,y可以为任何可以相加的对象

• 多态是对象的特性之一
• Python语言天然具有多态性

class Foo:__neme='happy'book='python'
#双下划线标记可以实现私有化
#私有化可以用于方法和属性
#私有化的特性与C++基本相同

• 封装是对象的特性之一
• Python中使用私有化的方式实现封装

定制类

class RoundFloat:def __init__(self,val):self.value=round(val,2)def __str__(self):return "{0:.2f}".format(self.value)__repr__=__str__
#str产生一个用户易于理解的字符串
#repr产生一个解释器友好的东西
#举例：
class Foo:def __repr__(self):return "I am in repr"def __str__(self):return "I am in str"
>>>f=Foo()
>>>f
I am in repr
>>>print(f)
I am in str

• 注意属性的访问控制

控制属性访问

• 优化内存__slots__
• 相关特殊方法：
  • __getattr__
  • __setattr__

注意：__dict__可以查询实例的属性

class Bar:__slot__=('name','age')
#限制该类只有这两种属性__getattr__#尝试读取某个不存在的属性时，调用此函数__setattr__#常识给某个不存在的属性赋值时，调用此函数

迭代器和生成器

迭代器

• 列表，字符串，字典=可迭代对象
• 查看方法就是该对象是否有__iter__方法（使用的函数时hasattr）
• hasattr(iter_lst,”__iter__”)查询iter_lst对象是否有__iter__

lst=[1,2,3,4]
iter_lst=iter(lst)
#迭代器对象也是可迭代对象
#迭代器对象有一个特殊方法__next__
#调用一次就向后读取一个对象

• 迭代器有利于优化内存（因为一次只读入一个数字到内存）

• import itertools可以调用迭代器工具

• import itertools
  counter=itertools.count(start=7)
  >>>next(counter)
  7
  >>>next(counter)
  8
  >>>next(counter)
  9
  

生成器

• 是迭代器对象

• 是可迭代对象

• def g():yield 0yield 1yield 2yield 3yield 4
  #当迭代器对象运行到yield时，生成器对象暂停，并返回指定内容
  gt=(x**2 for s in range(10))
  #以上为生成器解析
  #gt为生成器对象
  

• 生成器在形式上更接近函数

Python模块与库

标准库与第三方包

import module
from module import function
import module as other_name

• 安装：pip install package_name

• 来源：https://pypi.org/

• 在idle中^D退出idle

pip install requests==2.0
#指定第三方包的版本
pip install --upgrade requests
#升级指定第三方包
pip list
#查看已经安装的第三方包
pip uninstall package_name
#卸载第三方包

• 使用国内镜像

#临时使用
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple some-package
#设为默认
pip install pip -U
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
#升级pip
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U

编写和发布模块

• 模块：.py文件

• if __name__ == "__main__":
  #如果该py文件为运行的py文件，则name为__main__
  #如果该py文件为module，则name为模块名
  

• #修改模块搜索路径
  sys.path.append('dirpath')
  sys.path
  #查看路径
  

• 包：有一定层次的目录结构

  • 包含py文件或子目录
  • __init__（包的没有目录必定含有，可以为空）

• import . import module
  #当前目录下引入模块
  import ..B import Module
  #返回上级目录 查找B目录 引入B目录下Module
  

发布

非重点

文件读写

import os
os.getcwd()
#显示当前工作目录
f=open("text.txt","w")
#没有则创建（在内存中，未保存到磁盘中）
f.write("str")
f.close()
#保存
f.read()
f.readline()

模式	说明
r	读取，默认方法
w	写入，若存在，则覆盖，若不存在，则新建
a	写入，若存在，则追加，若不存在，则新建
b	以二进制模式打开，不单独使用，配合rwa模式
+	同时实现读写操作，不单独使用，配合rwa模式
x	创建，但如果存在，无法创建

上下文管理器

• with open("test.txt",'a') as f:f.write('\ntest')
  #上下文管理器自动保存
  

• for line in f:print(line)
  #遍历文件
  f.seek(0)
  #指针回位0
  

csv文件操作

• import csv
  #操作csv文件必备
  with open("csvfile.csv",'w') as f:writer=csv.writer(f)#必须创建writer.writerows(data)
  #data是一个二位列表
  with open("csvfile.csv",'r') as f:reader=csv.reader(f)#必须有for row in reader:print(row)
  

excel文件操作

• import openpyxl
  #操作excel文件必备
  from openpyxl import Workbook
  wb=Workbook()
  #操作工具对象
  ws=wb.active
  ws.title
  #默认表格
  ws2=wb.create_sheet('java')
  #创建新工作簿
  wb.sheetnames
  #查询所有工作簿名字
  ws['E1']=111
  #单元格坐标E1赋值
  ws.cell(row=2,column=2,value=222)
  #单元格坐标2，2赋值
  wb.save('example.xlsx')
  #保存
  

异常处理

try:#运行语句
except ZeroDivisionError:#可以选择异常来处理if self.is_raise:return "Zero can no be division"else:raise#把当前异常显示到终端
except ValueError:#另外一种异常处理
except (ZeroDivisionError,ValueError):#同时接受两种异常

语音合成

SDK和API

Software Development Kit: 软件开发工具包一般都是一些软件工程师为特定的软件包、软件框架、硬件平台、操作系统等建立应用软件时的开发工具的集合。

Application Programming Interface: 应用程序接口是一些预先定义的接口（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定。用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节。

百度语音合成SDK

python-SDK

简介

Hi，您好，欢迎使用百度语音合成服务。

本文档主要针对Python开发者，描述百度语音合成接口服务的相关技术内容。如果您对文档内容有任何疑问，可以通过以下几种方式联系我们：

• 在百度云控制台内提交工单，咨询问题类型请选择人工智能服务；
• QQ群快速沟通： AI开放平台官网首页底部“QQ支持群”中，查找**“百度语音”**。

接口能力

接口名称	接口能力简要描述
语音合成	将计算机自己产生的、或外部输入的文字信息转变为可以听得懂的、流利的口语输出的技术。

注意事项

目前本SDK的功能同REST API，需要联网调用http接口 。REST API 仅支持最多512字（1024 字节)的音频合成，合成的文件格式为mp3。没有其他额外功能。 如果需要使用离线合成等其它功能，请使用Android或者iOS 合成 SDK

请严格按照文档里描述的参数进行开发。请注意以下几个问题：

1. 合成文本长度必须小于1024字节，如果本文长度较长，可以采用多次请求的方式。切忌文本长度超过限制。

2.新创建语音合成应用可以在控制台领取免费额度。

1. 必填字段中，严格按照文档描述中内容填写。

版本更新记录

上线日期	版本号	更新内容
2022.2.26	4.15.4	接口统一升级
2017.5.11	1.0.0	语音合成服务上线

快速入门

安装语音合成 Python SDK

语音合成 Python SDK目录结构

├── README.md
├── aip                   //SDK目录
│   ├── __init__.py       //导出类
│   ├── base.py           //aip基类
│   ├── http.py           //http请求
│   └── speech.py //语音合成
└── setup.py              //setuptools安装

支持Python版本：2.7.+ ,3.+

安装使用Python SDK有如下方式：

• 如果已安装pip，执行pip install baidu-aip即可。
• 如果已安装setuptools，执行python setup.py install即可。

** 新建AipSpeech**

AipSpeech是语音合成的Python SDK客户端，为使用语音合成的开发人员提供了一系列的交互方法。

参考如下代码新建一个AipSpeech：

from aip import AipSpeech""" 你的 APPID AK SK """
APP_ID = '你的 App ID'
API_KEY = '你的 Api Key'
SECRET_KEY = '你的 Secret Key'client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)

在上面代码中，常量APP_ID在百度云控制台中创建，常量API_KEY与SECRET_KEY是在创建完毕应用后，系统分配给用户的，均为字符串，用于标识用户，为访问做签名验证，可在AI服务控制台中的应用列表中查看。

配置AipSpeech

如果用户需要配置AipSpeech的网络请求参数(一般不需要配置)，可以在构造AipSpeech之后调用接口设置参数，目前只支持以下参数：

接口	说明
setConnectionTimeoutInMillis	建立连接的超时时间（单位：毫秒
setSocketTimeoutInMillis	通过打开的连接传输数据的超时时间（单位：毫秒）

接口说明

语音合成

接口描述

基于该接口，开发者可以轻松的获取语音合成能力

请求说明

• 合成文本长度必须小于1024字节，如果本文长度较长，可以采用多次请求的方式。文本长度不可超过限制

举例，要把一段文字合成为语音文件：

result  = client.synthesis('你好百度', 'zh', 1, {'vol': 5,
})#识别正确返回语音二进制 错误则返回dict 参照下面错误码
if not isinstance(result, dict):with open('audio.mp3', 'wb') as f:f.write(result)

参数	类型	描述	是否必须
tex	String	合成的文本，使用UTF-8编码， 请注意文本长度必须小于1024字节	是
cuid	String	用户唯一标识，用来区分用户， 填写机器 MAC 地址或 IMEI 码，长度为60以内	否
spd	String	语速，取值0-9，默认为5中语速	否
pit	String	音调，取值0-9，默认为5中语调	否
vol	String	音量，取值0-15，默认为5中音量	否
per	String	发音人选择, 0为女声，1为男声， 3为情感合成-度逍遥，4为情感合成-度丫丫，默认为普通女	否

返回样例：

// 成功返回二进制文件流
// 失败返回
{"err_no":500,"err_msg":"notsupport.","sn":"abcdefgh","idx":1
}

错误信息

错误返回格式

若请求错误，服务器将返回的JSON文本包含以下参数：

• error_code：错误码。
• error_msg：错误描述信息，帮助理解和解决发生的错误。

错误码

错误码	含义
500	不支持的输入
501	输入参数不正确
502	token验证失败
503	合成后端错误

网络爬虫

import requests
from lxml import htmlurl="https://www.csdn.net/"page = requests.get(url).content.decode("utf-8")print (page)

• 正则表达式
• 需要一些前端知识

Python数据库操作

SQLite

• 小型关系数据库
  • 不需要单独的服务
  • Python内置驱动模块
  • 像文件一样操作

import sqlite3
conn=sqlite3.connect("./sqlite/db")
cur=conn.cursor()
create_users_table="""
CREATE TABLE IF NOTE EXISTS users(
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
age INTEGER,
gender TEXT
);
"""
cur.execute(create_users_table)#执行语句
create_users="""
INSERT INTO
users (name,age,gender)
VALUES
("zhangsan",25,"male"),
("lisi",45,"male");
"""
cur.execute(create_users)
conn.commiot()#操作保存
select_users="select * from users"
cur.execute(select_users)
result=cur.fetchall()
>>>result# 查看查询结果
cur.close()
conn.close()

MySQL

Python Database API,为大多数的数据库实现了接口，使用它连接各种数据库后，就可以用相同的方式操作各数据库

使用流程

1. 引入API模块
2. 获取与数据库的连接
3. 执行sql语句和存储过程
4. 比数据库连接

方法

• 两个针对事务的方法
  • commit()提交
  • rollback()回滚
• cursor的方法
  • callproc(self,procname,args)
  • execute(self,query,args)执行sql语句

《零基础掌握 Python 入门到实战》笔记相关推荐

1. 《信贷的逻辑与常识》笔记

   序 银行信贷风险管理的反思 现状与趋势 银行贷款的质量变化与经济周期.宏观调控政策等存在很高的相关性 现在银行不良贷款的增加主要是前几年经济快速增长时企业过度投资.银行过度放贷所带来的结果. 从历史情 ...

2. AI公开课：19.02.27周逵(投资人)《AI时代的投资逻辑》课堂笔记以及个人感悟

   AI公开课:19.02.27周逵(投资人)<AI时代的投资逻辑>课堂笔记以及个人感悟 目录 课堂PPT图片 精彩语录 个人感悟 课堂PPT图片 精彩语录 更新中-- 文件图片已经丢失-- ...

3. 人工智能入门算法逻辑回归学习笔记

   逻辑回归是一个非常经典的算法,其中也包含了非常多的细节,曾看到一句话:如果面试官问你熟悉哪个机器学习模型,可以说 SVM,但千万别说 LR,因为细节真的太多了. 秉持着精益求精的工匠精神不断对笔记进行 ...

4. 【逻辑回归学习笔记】

   算法描述 1.逻辑回归要做的事就是寻找分界面实现二分类. 2.问题假设:对一堆三角形和正方形分类. 3.数据输入:已知正方形和三角形的坐标和标签. 4.算法过程: 知识储备 1.分类和回归 ①分类的目 ...

5. 逻辑回归函数学习笔记

   继续逻辑回归学习,今日笔记记录. 1.逻辑回归和线性回归的关系:对逻辑回归的概率比取自然对数,则得到的是一个线性函数,推导过程如下. 首先,看逻辑回归的定义 其次,计算两个极端y/(1-y),其值为( ...

6. 2.2 逻辑回归-机器学习笔记-斯坦福吴恩达教授

   逻辑回归 上一节我们知道,使用线性回归来处理 0/1 分类问题总是困难重重的,因此,人们定义了逻辑回归来完成 0/1 分类问题,逻辑一词也代表了是(1) 和 非(0). Sigmoid预测函数 在逻辑 ...

7. LVM逻辑卷分区笔记

   磁盘的静态分区有其缺点:分区大小难评估,估计不准确,当分区空间不够用的时候,系统管理员可能需要先备份整个系统,清除磁盘空间,然后重新对磁盘进行分区,然后恢复磁盘数据到新分区,且需要停机一段时间进行恢复 ...

8. 适合理工直男的钟平老师逻辑英语学习笔记

   一切的一切都只是套路!             --鲁迅 核心公式: En: (状语1) 主(定语1) 谓(状语2) (宾)(定语2) (状语1) Ch: (状语1) (定语1)主 (状语2)谓 (定 ...

9. 【数字逻辑】学习笔记 第四章 Part2 常用组合逻辑电路与竞争、险象

   文章目录 一.常用组合逻辑电路 1. 译码器 (1) 二进制译码器 74LS138(3/8译码器) a. 一般符号和图形符号 b. 74LS138功能表 c. 两片 `74LS138` 构成 `4-1 ...

10. 线性回归、逻辑回归学习笔记

    学习源代码 import numpy as np import matplotlib.pyplot as plt def true_fun(X): # 这是我们设定的真实函数,即ground trut ...

最新文章

1. 【Timbre,Amplitude,Pitch】声音的基本属性
2. java ide 2017_Intellij ide 2017.2新建javaweb项目，并且部署
3. MySql 5.7 重置root密码
4. Matlab中存储及读取数据
5. php：自定义session
6. MySQL 集群方案介绍
7. .NET Core 在中国的现状调研
8. 由相机的自身参数求解内参矩阵
9. WPF的ComboBox 数据模板自定义
10. （二）Netty之IO模型
11. memcached学习笔记（1）——memcached原理
12. 苹果Mac视频格式转换器：Filmage Converter
13. 转一篇帖子-我是如何在网上卖鱼的
14. @EnableScheduling和@Scheduled的使用
15. 与或非逻辑运算符用法详解
16. Integer关于equals与==的比较（自动拆装箱技术和常量池技术）
17. 使用MVC模式实现一个超简单的网上书店系统
18. 12.3明德杨UART_TX调试经验
19. 《单片机原理及应用》(B)课程教学大纲
20. 绿盟rsasnx3_绿盟RSASNX3-S远程安全评估系统V6.0

热门文章

1. ABP VNext学习日记18
2. ABP理论学习之本地化
3. 2022年深圳市科技型中小微企业贷款贴息资助标准及申报条件，补贴100万
4. 【数说】人气网文修炼手册之最深的网文套路知多少
5. STM32F407使用串口3获取攀腾G7的PM2.5数据
6. ubuntu 16换源方法
7. 用ADC0809实现八通道采集
8. 【SCIR笔记】ACL2020表格预训练工作速览
9. canvas.toDataURL()降低图片质量，以减少图片上传大小
10. MT4MT5EA编程跟单系统EA