集合
1、set(str)
add() 添加，位置随机，整体添加
update() 添加，位置随机，拆分添加
remove('str1') 删除某个元素
符号 & 交集 intersection() 语句 集合1.intersection(集合2)
| 合集 union() 语句 集合1.union(集合2)
- 差集 difference() 语句 集合1.difference(集合2)
有两个集合，s1和s2，求两个集合相交的部分（s1 & s2）(s1.intersection(s2))，求两个集合的合集（s1 | s2）(s1.union(s2))，求两个集合差集（s1-s2）?
计算字符串中，某个字符出现的次数
str.count(str1,start,stop)
检测字符串含有指定的后缀；返回True，否则返回False。
str.endswith(str1)
检测字符串中是否包含子字符串 str ,如果包含返回字符的下标，不包含返回-1
str.find(str1)
返回索引
str.index(str1)
替换，返回一个新的字符串
replace(old,new,num)
字符串拆分为列表
split('') 语句 str.split("拆分符号")
去除收尾字符（相同）
str1.strip("str,str....")
-------------------------------------------------
os模块
os.sep 更改操作系统中的路径分隔符。
os.getcwd()获取当前路径，这个在Python代码中比较常用。
os.listdir() 列出当前目录下的所有文件和文件夹。
os.remove() 方法可以删除指定的文件。
os.system() 方法用来运行shell命令。
os.chdir() 改变当前目录，到指定目录中
os.mkdir(文件夹路径及名称)
open()
w 以写方式打开，
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
time
time.strftime('%Y-%m-%d',time.localtime())
random模块?
random.randint(a,b)随机整数,返回随机整数x,a<=x<=b
random.randrange(start,stop,[,step])返回一个范围在(start,stop,step)之间的随机整数，不包括结束值。
random.random( )随机实数,返回0到1之间的浮点数
random.uniform(a,b)返回指定范围内的浮点数。
random.choice(list/tuple)返回的是列表中的元素
定义函数的语法：
def 函数标识名称( 参数列表 ):
"函数_文档字符串，对函数进行说明"
函数体
return [表达式]
return [表达式] 结束函数，选择性地返回一个值给调用方。
不带表达式的return相当于返回(None)。
例子：
# 定义一个函数
def sum(arg1, arg2):
'返回两个参数之和'
total = arg1 + arg2
# 返回
return total
# 调用函数
total = sum(10, 20)
print('total', total)
----------------------------------------------------
变量作用域
局部变量：定义在函数内部的变量拥有一个局部作用域（只能在其被声明的函数内部访问）
例子：
# 定义一个全局变量
total = 10
# 定义一个函数
def sum(arg1, arg2):
'返回两个参数之和'
total = arg1 + arg2
# 函数内输出total(访问局部变量)
print('函数内访问total:> ' , total)
# 返回
return total
# 调用sum函数
sum(10, 20)
# 函数外输出total(访问全局变量)
print('函数外访问total:> ', total)
全局变量：定义在函数外的拥有全局作用域（可以在整个程序范围内访问）
例子:
# 全局变量
globalvar = 0
# 定义一个函数
def set_globalvar_one():
# 在函数内声明全局变量的内部作用域使用权
global globalvar
# 为全局变量赋值
globalvar = 1
# 定义一个函数
def print_globalvar():
# 先查找函数内是否有局部globalvar变量?
# 没有再找全局，再没有报错
print(globalvar)
print(globalvar) # 输出全局变量
# 调用set_globalvar_one()函数
set_globalvar_one()
# 调用pint_globalvar()函数
print_globalvar()
-------------------------------------------------------
不可变对象实例
# 定义一个函数
def changeInt(a):
a = 10
pass
b = 2
# 调用函数
changeInt(b)
# 输出b
print(b)
可变对象实例
# 定义一个函数
def changeList(myList):
'修改传入的列表'
myList.append([0,0,0])
print '函数内输出:>' , myList
return
list1 = [2,4,6]
# 调用函数
changeList(list1)
# 输出b
print '函数外输出:>' , list1
-----------------------------------------
参数
(1)必备参数：必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
例子：
# 定义一个函数
def printme(str):
'修改传入的列表'
print str
return
# 调用函数
printme()
(2)关键字参数:关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值
# 定义一个函数
def printinfo(name, age):
'屏幕输出姓名和年龄信息'
print('姓名：' , name)
print('年龄：' , age)
return
#调用函数
printinfo(age=18, name='卫斯理')
(3)缺省参数：调用函数时，缺省参数的值如果没有传入，则被认为是默认值
def printinfo(name, age = 35):
'屏幕输出姓名和年龄信息'
print('姓名：' , name)
print('年龄：' , age)
return
# 调用函数
printinfo(age = 18, name = '卫斯理')
printinfo(name = '狄仁杰')
(4)不定长参数:需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数
def 函数名称([formal_args,] *var_args_tuple ):
"函数_文档字符串"
函数体
return [表达式]
例子:
# 定义一个函数
def printinfo(arg1, *vartuple):
'屏幕输出任何输入参数'
print(arg1,) # 输出第一个参数
# for循环输出不确定长度的参数
for var in vartuple:
print(var,)
pass
return
#调用函数
printinfo(10)
printinfo(70, 60, 50)
例子：
# def list1(num1,num2,*num3):
# print(num1)
# print(num2)
# print(num3)
# list1(10,20,30,40)
函数的进阶应用
(lambda)来创建(匿名函数)。
特点
lambda只是一个（表达式），函数体比def简单很多。
lambda的主体是一个表达式，而（不是一个代码块）。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问 自有参数列表之外 或 全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
匿名函数语法
lambda [arg1 [,arg2,.....argn]] : 表达式
例子:
# 匿名函数的声明
var_sum = lambda arg1,arg2:arg1+arg2
# 调用var_sum对象
print('相加之后的值:> ' , var_sum(10, 20))
-----------------------------------------------------------
高阶函数：能接收函数做参数的函数
特点：
变量可以指向函数
函数的参数可以接收变量
一个函数可以接收另一个函数作为参数
例子:(1)
# 定义一个函数
def add(x, y, f):
# 返回abs(x)+abs(y)的值
return f(x) + f(y)
# 调用函数
print('结果为:> ', add(-2, 3, abs))
例子（2）
# 导入math模块，调用sqrt()求平方根函数
import math
# 定义一元二次求解高阶函数
# a, b, c为三个参数
# f1 为 math.sqrt()开平方根函数
def func(a, b, c, f1):
list1 = [] # 定义一个列表存放结果
# 验证：a不等于0
if a == 0:
return '错误: a 不能等于 0' # 返回报错
# 验证：b^2-4ac 大于 0
elif (b**2)-(4*a*c) > 0:
res1 = (-b + f1((b**2)-(4*a*c)))/(2*a) # 求解1
res2 = (-b - f1((b**2)-(4*a*c)))/(2*a) # 求解2
# 将结果添加到列表中
list1.insert(1, res1)
list1.insert(2, res2)
return list1 # 返回列表
else:
return '此题无解' # 返回信息
# 调用函数传递参数
res1 = func(2, -5, 2, math.sqrt)
print(res1) # 输出结果
--------------------------------------------------
python装饰器(代码重用的目的)
# 导入time模块
import time
# 自定义一个统计时间的高阶函数
def calcTime(func):
print('--> 开始计时.....')
startTime = time.time() # 使用time()获取时间戳
func() # 调用传入的函数
endTime = time.time() # 使用time()再获取时间戳
print('--> 结束计时.....')
msecs = (endTime - startTime) * 1000 # 计算两次时间差
# 输出结果
print('--> 性能测试结果：' + func.__name__ + '()函数耗时：%f ms' % msecs)
# 自定义一个测试函数
def func2():
print('func1() start...')
推迟执行的秒数time.sleep(0.6)
time.sleep(0.6) # 模拟0.6秒执行
print('func1() end...')
# 调用高阶函数
calcTime(func2)
# 自定义一个测试函数，装饰器方式，无需调用
@calcTime
def func2():
print('func1() start...')
time.sleep(0.6) # 模拟0.6秒执行
print('func1() end...')
例子（3）
def fun1(func):
print("返回值是》")
func()
@fun1
def fn1():
print(123)
------------------------
闭包：局部变量通过返回函数的形式，进行调用
例子：
def fun():
a=10
def fn():
b=2
print(a)
return fn
fun()()
______________--------------------------
判断内存地址id()
继承：一般情况下子类继承父类
在继承关系下，子类将会拥有父类全部的方法（即，父类方法可在子类对象中访问调用）
一般共有的方法可以抽象出来放在父类中，子类在继承父类的同时凸显出自己个性的方法。
纵向（深度）
# 创建父类
class Parentclass():
…………
pass
# 创建子类继承父类
class Childclass(Parentclass):
…………
pass
案例：
# 创建父类Animal
class Animal():
# 定义通用方法
def eat(self):
print('%s 吃' % self.name)
pass
def drink(self):
print('%s 喝' % self.name)
pass
# 创建子类Cat
class Cat(Animal):
# 定义构造方法
def __init__(self,name):
self.name=name
pass
# 定义叫call
def call(self):
print('%s 喵喵' % self.name)
pass
cat=Cat('猫')
cat.eat()
多重继承
Python的类可以继承多个类，不像很多高级编程语言Java和C#那样只能继承一个类（单根语系）。
在早期的2.x版本中分为经典类时，会按照深度优先方式查找；新式类时，会按照广度优先方式查找
现在3.x中，取消经典类，都是新式类，都是广度优先方式
# 创建父类
例子：
class C1:
def method(self):
print('C1 -> method()')
class C2(C1):
def method1(self):
print('C2 -> method()')
class C3(C1):
def method1(self):
print('C3 -> method()')
class C4(C3, C2): #多继承
def method1(self):
print('C4 -> method()')
c=C4()
c.method()
灵活性（鸭子类型）
class F1:
pass
class S1(F1):
def show(self):
print('S1.show()')
class S2(F1):
def show(self):
print('S2.show()')
def Func(obj):
print(obj.show())
#创建S1类对象
s1_obj = S1()
Func(s1_obj)
# 创建S2类对象
s2_obj = S2()
Func(s2_obj)
--------------------------------------
super()
在Python面向对象的继承特征下，若子类需调用父类的方法，则需要使用super（）来实现。super（）只能用于新式类中。
super（）和 __init__实现的功能是基本一致的。
例子
# 父类（基类）
class Base:
def __init__(self):
print('Base create')
# 子类（派生类）
class childA(Base):
def __init__(self):
print('creat A ')
Base.__init__(self)
# 子类（派生类）
class childB(Base):
def __init__(self):
print('creat B ')
super(childB,self).__init__()
childA()
childB()
---------------------------分隔符号--------------------------------
例子：（使用super避免重复）
# 父类（基类）
class Base(object):
def __init__(self):
print('Base create')
# 子类（派生类）
class childA(Base):
def __init__(self):
print('start A ')
super(childA, self).__init__()
print('end A ')
# 子类（派生类）
class childB(Base):
def __init__(self):
print('start B ')
super(childB, self).__init__()
print('end b ')
class childC(childA, childB):
pass
# 创建C类的对象
c = childC()
#查看对象obj的类及其继承顺序
print(c.__class__.__mro__)
对上面例子改：
# 父类（基类）
class Base(object):
def __init__(self):
print('Base create')
# 子类（派生类）
class childA(Base):
def __init__(self):
print('start A ')
Base.__init__(self)
print('end A ')
# 子类（派生类）
class childB(Base):
def __init__(self):
print('start B ')
super(childB, self).__init__()
print('end b ')
class childC(childA, childB):
pass
# 创建C类的对象
c = childC()
#查看对象obj的类及其继承顺序
print(c.__class__.__mro__)
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。
Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。
re 模块使 Python 语言拥有全部的正则表达式功能。
一、math()字符串的起始位置匹配一个模式，匹配成功re.match方法返回一个匹配的对象，否则返回None。
re.match(pattern, string, flags=0)
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
例子：
import re
str1='hello world'
print(re.match('h',str1).span())
print(re.match('d',str1))
二、roup(num=0)用来提出分组截获的字符串
例子
import re
a = "123abc456"
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)) #123abc456,返回整体
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)) #123
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)) #abc
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)) #456
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置
group和groups是两个不同的函数?
一般，m.group(N) 返回第N组括号匹配的字符。
而m.group() == m.group(0) == 所有匹配的字符，与括号无关，这个是API规定的。
m.groups() 返回所有括号匹配的字符，以tuple格式。
m.groups() == (m.group(0), m.group(1), ...)
三、re.search() 扫描整个字符串并返回第一个成功的匹配
re.search(pattern, string, flags=0)
例子：
import re
print(re.search('www', 'www.runoob.com').span()) # 在起始位置匹配
print(re.search('com', 'www.runoob.com').span()) # 不在起始位置匹配
re.match与re.search的区别?
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
四、re.sub() 替换字符串中的匹配项
re.sub(pattern, repl, string, count=0)
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
例子：
import re
# 这是一个电话号码"
tel = "2004-959-5#5#9"
# 删除注释
num = re.sub(r'#*', "", tel)
print("电话号码 : ", num)
# 移除非数字的内容
num = re.sub(r'\D', "", tel)
print ("电话号码 : ", num)
五、re.compile 用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用
语句：
re.compile(pattern[, flags])
pattern:一个字符串形式的正则表达式
flags:可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
例子：
import re
pattern = re.compile(r'\d+') # 用于匹配至少一个数字
# m = pattern.match('one12twothree34four') # 查找头部，没有匹配
# print(m)
# m=pattern.match('one12twothree34four',2, 10) # 从'e'的位置开始匹配，没有匹配
# print(m)
m=pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
# print(m) # 返回一个 Match 对象
# print(m.group(0))
# print(m.span(0))
# print(m.start(0))
# print(m.end(0))
例子：
import re
patt=re.compile(r'[a-z]{1}')
txt=" abcd "
t=patt.search(txt,0,len(txt)-1)
print(t.group())
六、findall() 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意：match 和 search 是匹配一次 findall 匹配所有。
import re
text = 'python is good, php is good'
regex = re.compile(r'\w*o\w*')
print(regex.findall(text)) #查找所有包含’oo’的单词
七、finditer()和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
import re
it = re.finditer(r"\d+","12a32bc43jf3")
for match in it:
print(match.group())
八、split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
split(pattern, string[, maxsplit=0, flags=0])
import re
txt=re.split(r'_,', 'runoob_,runoob_runoob')
print(txt)
#可选标志
# re.I 使匹配对大小写不敏感
# re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
# re.M 多行匹配，影响 ^ 和 $
# re.S 使 . 匹配包括换行在内的所有字符
# re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
# re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
#表达式模式
# ^ 匹配字符串的开头
# $ 匹配字符串的末尾。
# . 匹配除了换行符以外的任意字符
# [...] 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
# [^...] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
# \w 匹配字母数字及下划线
# \W 匹配非字母数字及下划线
# \s 匹配任意空白字符，等价于 [\t\n\r\f].
# \S 匹配任意非空字符
# \d 匹配任意数字，等价于 [0-9].
# \D 匹配任意非数字
# \A 匹配字符串开始
# \Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c
# \z 匹配字符串结束
# \G 匹配最后匹配完成的位置。
# re* 匹配0个或多个的表达式。
# re+ 匹配1个或多个的表达式。
# re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
# re{ n}
# re{ n,} 精确匹配n个前面表达式。
# re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
# a| b 匹配a或b
enumerate 获取索引
单下划线组合的变量属于protected self._name
双下划线组合的变量属于private self.__name
无下划线组合的变量属于public self.name
public
公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
class C:
name = "公有静态字段"
def func(self):
print(C.name)
class D(C):
def show(self):
print(C.name)
C.name # 类访问
obj = C()
obj.func() # 类内部可以访问
obj_son = D()
obj_son.show() # 派生类中可以访问
私有普通字段：仅类内部可以访问；
class C:
def __init__(self):
self.__foo = "私有字段"
def func(self):
#类内部访问
print(self.__foo)
class D(C):
def show(self):
#派生类中访问
print(self.__foo)
obj = C()
obj.__foo
obj.func()
obj_son = D();
obj_son.show()
205
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
