python 学习笔记
2017-09-18 09:38
295 查看
boolean isinstance(判断对象,判断类型)
if isinstance(temp,str):
2: 导入对象 import import 导入的是模块 模块的方法是内置函数
3: input('请输入') 获取键盘输入对象
4:随机数 import random
random.randint(1,10) 返回一个 1-10 内的随机数
5: 类型转换 转换对象+() m = int(m)
m = int() 意思就是 m = 0
6: 判断符号
+=,-=,*=,/=,%=,**=,<<=,>>=,&=,^=,|= 自变运算符 通常用于数字
<,<=,>,>=,==,<>,!= 比较运算符 通常用于字符串
7: 对象
列表 [] 符号分割 内置对象之间用 , 分割开来
普通列表 混合列表: m = [1,2,3,'23']
空列表: m = []
元素添加:append()
extend(list) 将一个列表添加到此列表对象内
insert(1,2) 1是下标位置 2是对象 如果下标超过len(list) 自动在列表后追加,否则插入指定位置,此位置后的元素均向后错位一位
元素删除:remove('参数名称') 注意 两个相同对象的列表 只能删除一个对象
del mem[1] 下标为1 的对象从列表中删除
del mem 从内存中删除整个列表
pop(1) 不加参数默认删除最后一个 加参数删除下标为参数内对象的对象
如果列表内有字符串,列表和数字组合的话,默认元素首尾是 " " 符号来表示一个列表元素
列表分片:为了一次性获取多条元素
list[1:2] 没有1 2 的话 默认获取列表所有元素
只有1 从1指定下标开始截至到列表结束内的元素
只有2 从0开始到下标为2 的元素集合
有1 和 2 从1 开始到2结束 不包括2 的元素集合
正向 反向索引 -1 表示最后一个元素 list2=list[-1:] 只获取最后一个元素
列表常用操作符:
< = > 比较的是列表的第一个元素的大小 = 号是相同的列表
* 列表相加 list1 * 3 = [123,345,123,345,123,345] 等同于三个字符串相加
in not in 函数 类似 java 的 contains 方法 返回 布尔类型值 注意 多层列表的话 无法判断 只能当层列表
count(obj) 元素在列表出现的次数
index(obj,1,2) 如果有1 2 参数的话 表示obj 在列表中从1开始到2结束内所在的位置
注意 这里只返回一个值,如果有多个相同的话是无法识别的
reverse 列表翻转
sort() 默认自动排序
逻辑操作符 and or
元组: 带上了枷锁的列表 和 str int flot list 一样 元组有自己的类型 tuple
定义元组后 内置的元素不可改变
元组创建:tuple = (1,2,3) 或者 tuple =1,2,3 注意 元组是以 () 来包围元素的 和 list 的 [] 不同
注意 元组中如果只有一个元素的时候,在此元素后加逗号避免歧义 tuple=(123,)
元组更新: 采用tuple[x:y] 方式分解元组 然后创建新的元组 tuple1+tuple2 即可成为新的元组
元组删除: del tuple
元组内置函数:1、cmp(tuple1, tuple2):比较两个元组元素。
2、len(tuple):计算元组元素个数。
3、max(tuple):返回元组中元素最大值。
4、min(tuple):返回元组中元素最小值。
5、tuple(seq):将列表转换为元组。
能用元组 最好不要用list 因为更安全
字符串:
capitalize() 把字符串第一个字符改为大写
casefold() 所有字符串改为小写
count("abc") abc 在字符串出现的次数
endswith("abc") 判断是否以 abc 结尾 注意 这里是区分大小写的
startswith("abc") 判断是否以 abc 开头
find("a") 判断a 是否在字符串内,有的话返回索引值 索引以 0 开头 如果没有的话 返回 -1
index("a") 和 find 一样 只不过没有字符串的话会返回异常
isalpha() 都是字母 返回 true
isalnum() 字符或数字 true
isdigit() 只包含数字 true
lover() 转换所有大写为小写
lstrip() 去掉左边空格
rstrip() 去掉尾部空格
strip() 删除字符串首尾两端所有空格
encode(encoding='utf-8',errors='strict') 指定编码格式进行编码
replace(old,new,count) new 替换 old count 指定的话替换不超过 count次哦
集合 set 从2.3 版本以后就可以不用导入set模块 符号:set([])
注意: 能用set 不要用 list
set 无序不重复的集合 并且支持 union(联合) intersection(交) difference(对称差集)
sets 支持 x in set, len(set) 和 for m in set:
作为一个无序集合,set 并不支持 indexing slicing 或其他类序列的操作
set 创建:x = set(['hello']) set元素不允许有 list 和tuple
注意 set 外面嵌套两层 内层是[] 外层是 () 哪怕只有一个元素也要两个符号都有 不然 交集 并集 差集无法实现
x & y 取交集
x | y 取并集
x - y 取差集 x有 y 没有
set 添加: add() 添加一条元素
update([1,2,3]) 添加多项元素 可以添加set list 元组 等别的数据类型
set 删除: remove(元素值) 可以删除一项
len(set) 长度 x in set 测试是否在set 里 in not in
boolean = x.issubset(y) 测试 x 中的每个元素是否都在 y里 返回 boolean
set = x.union(y) 返回新set 包含两个 x y 所有元素
x in y 测试 x 是否是y 的成员
为啥 x=set([1]) y=set([1,2,3,4,5] m = x in y print(m) 这里是False 但是 m 换成1 后就是Ture
注意 这里的x 为单独的一个元素 不能是set
x.issubset(y) x y 都是set sub后是爹 super 后是儿子
x.issuperset(y)
x.union(y) x y 集合所有元素
x.intersection(y) 包含x 和y 的公共元素
x.difference(y) x 有 y 没有的set 元素
字典:python 中唯一的映射类型
字典和序列类型的区别:存储和访问数据的方式不同
序列类型只用数字型的键(set除外),映射类型可以用其他对象类型做键,并且键值有一定的关系
映射数据无序排列
映射类型用键直接映射到值
字典的创建: adict = {} 一个大括号符号 或者 m = dict()
adict = {k1:value1,k2:value2,l3:value3}
两种创建方式: 1 maps = {'李宁':'一切皆有可能','耐克':'just do it','阿迪':'Impossible is nothing','特步':'非一般的感觉'}
2 maps = dict(特步='非一般的感觉',李宁='一切皆有可能') # 这里key 不允许用引号 会自动转换成字符串
注意: 键值分开 用: 区别
项与项 之间用 , 号 分开
字典中的键必须是唯一的,而值可以不唯一
keys() 打印出所有的key values() 打印出所有的值 items() 所有
字典的添加: dict[key] = value 更新一个值也是一样的
setdefault(5,'value') 随机添加一个字典内的键值对
dict.update(字典对象)
字典的删除: del dict[key] 删除某个键值对
del dict 删除整个字典
adict.clear() 删除字典中的所有项或元素
dict.pop(key) 删除 key 项并返回 key 对应的value
字典内键值判断:
in 或 not in 判断一个key 是否在字典key中
字典值得查询: dict.get(key) 获取 value 值
8: 函数 多参数,不定参数,多返回值,闭包 重点
def test():
代码块 调用函数的话 test() 注意:参数可以是任何数据类型 字符串 数字 浮点 列表 元组 集合 字典
参数: 形参 def test(obj) 这里 obj 就是形参 没有实际值
实参 test("obj") 这里 obj 就是实参
注意 调用的时候 多个参数可以在实参前加上形参名称
如 def demo(name,world):
print(name+world)
demo(world="改变世界",name="guoxinjie") 顺序不会改变
默认参数:定义了默认值的参数
def demo(name="guoxinjie",world="改变世界"):
print(name+world)
测试: demo(world="改变世界",name="guoxinjie")
搜集参数: 搞不清楚需要多少个参数 其实参数就是元组 注意 这里如果有固定参数的话 调用的时候 添加上默认参数就可以混用了
# 收集参数 通常情况下coder 并不知道需要多少个参数
def demo1(*params):
print("穿入参数个数: ",len(params));
print("第一个参数:"+params[1]);
demo1(1,"2",3,4,5)
多结果返回 返回结果是一个元组,这点功能大赞,是java比拟不了的 ***************
变量: python引用变量的顺序: 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量
函数变量的作用域:
局部变量:local Variable
全局变量:Global Variable java没有全局变量 只有实例变量 方法体外
在全局变量定义后 在函数内重新定义全局变量 python 会为该变量重新定义一个名称相同的变量,但是全局变量并不会被改变
内嵌函数: global 定义在函数内部的变量前,可以修改全局变量的值
lambda m = lambda x,y:(x+2)*y m(1,2) = 6 注意参数和表达式中间用 分号隔开
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
闭包: 一个闭包就是你调用了一个函数A,这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。
闭包是在一个function 上 return function 内部的 function2 注意 这里的 function2 不加括号的
如: def test1():
def test2():
print('11')
return '22'
return test2 ##这里反馈test2 函数 这里 test2 就是一个闭包
闭包可以被理解为一个只读的对象,你可以给他传递一个属性,但它只能提供给你一个执行的接口。因此在程序中我们经常
需要这样的一个函数对象——闭包,来帮我们完成一个通用的功能,比如后面会提到的——装饰器。
我们在编程时经常会把通用的东西抽象成类,(当然,还有对现实世界——业务的建模),以复用通用的功能。闭包也是一样,
当我们需要函数粒度的抽象时,闭包就是一个很好的选择。
工厂函数(factory function)
Python2.2统一了类型和类,所有的内建函数现在都也是类,在这基础上,原来的所谓的内建转换函数像int()、type()、list()等,现在都成了工厂函数。
虽然看上去像函数,但实质上它们是类,当你在调用它们时,实际上生成了该类的一个实例,就像工厂生产货物一样。
int()、long()、float()、complex()、str()、unicode()、basestring()、list()、tuple()、type()
dict()、bool()、set()、frozenset()、object()、classmethod()、staticmethod()、super()、property()、file()
内建函数(Built-in Functions),个人觉得就是自带的、标准的函数
9: 类和对象 一切皆对象 python 对象 = 属性+方法
注意打印语句 print('我叫%s,该死的谁踢我'% self.name) %s 表示需要打印的对象
类是对象的模板或蓝图,类是对象的抽象化,对象是类的实例化。类不代表具体的事物,而对象表示具体的事物。
class people: 注意 对象是没有() 只有方法函数才有():
类 默认打印方法 _str__(self): 打印对象的时候默认打印这个方法内的信息
默认初始化方法: __init__(self) 类初始化方法 里边传参来使用
zhangsan.speak()就好比写成了peo.speak(zhangsan) 这里self参数就会告诉方法是哪个对象来调用的.这称为实例引用、
注意: python 类创建后,setAttribute 和 .attribute 区别
通过重写构造方法来传入参数
类私有变量: 在类里变量前加上 __ 符号即可
类的继承: class test(基类) 或者 在类前添加 __metaclass__ = 基类
注意: 1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。有别于C#
2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。
(先在本类中查找调用的方法,找不到才去基类中找)
类或方法的文档 访问的
类的创建: 默认首字母大写
类的函数-- 必须有 self 作为第一个参数 ************************
def __init__ 初始化函数或者 构造函数 如果外面没参数的话,默认初始化在这里 def __init__(self,name='gg',age=12)
在 __init__ 中还可以添加属性让外部实例访问到但并不用在外部初始化
__init__(self): self.name = 'gg' p = Person() p.name = 'gg'
同时不但在 __init__ 中添加属性,在别的方法也可以,但是必须确保实例调用赋值所在的方法才可以访问到
类属性和实例属性:
类属性 -- 类的属性,不是独立的一个对象
实例属性 -- 类被实例化后的实际值 但是 类属性不会随着实例属性ongoin的改变而改变
class Person: x = 7 m = Person() m .x = 8 但是 Person.x =7 就是这个意思
实际上 m.x = 8 等于新建了一个属性,但是这个属性和原来的属性 Person.x 重名 于是Person.x 值被覆盖了,del m.x 后就出来了
但是 类的属性一定会影响到实例属性,类属性改变了,实例属性也会改变
有例外: 当类属性不是整数的时候,比如列表, 双方都会影响对方的
所以 不要轻易在实例属性修改类属性,这样的话实例化的其他对象都会受影响的
如果增加了类属性,实例属性一定会增加,但是增加了实例属性,类属性不受影响
注意: 如果在类中创建了成员变量,在该类的方法中是无法被访问到的,只有通过 __init__(self) 这个参数赋值后类方法才可以通过self 来使用
如果在类初始化中创建一个变量(或者类初始化的变量) 该变量在类中任何一个方法中被重新修改,那么无论是其他方法调用还是被实例化的
对象调用,这个变量的值都会随着改变而改变 下面我们看下他们的id是否改变,结果证实 ID 也会随着变化的。
之所以不推荐创建类的属性值 是因为这个是可变的,并且任何一处定义了都能改变值,维护非常困难,一般建议通过self 来传值
类的继承: inheritance
Object = Class(SuperClass)
注意: 子类中在对 __init__ 内的变量在其他任何方法上做修改,内外值都会随着改变
子类重写了父类的属性或者方法后,父类的信息都会改变
多重继承: class A classB c = classC(A,B) 顺序按照AB 顺序来
Super() 调用显示父类的属性或函数 在重写的时候调用可以延续父类的属性或方法,子类可选是否借用父类
格式为: super(父类,参数self).__init__() 父类函数
静态方法: 使用前提,需要一个参数不能让别人进行修改,在非特定环境下该静态变量或方法外部修改无效,只有在特定环境下修改才可行
如 IND = 'ON'
class Kls(object):
def __init__(self, data):
self.data = data
@staticmethod 表明这是一个静态方法
def checkind():
IND = "OFF" ### 只有在这里修改才有效
return (IND == 'ON') 在别的地方也可以修改这个值 但是在调用这个方法的时候 IND 始终是OFF (已修改) 不会再有别的值
def do_reset(self):
IND = 'OFF' ##这里修改无效
if self.checkind():
print('Reset done for:', self.data)
def set_db(self):
if self.checkind():
self.db = 'New db connection'
print('DB connection made for: ', self.data)
类方法: @classmethod 表示下面的方法是类方法 将类本身作为对象进行操作的方法
注意 必须至少有一个参数 cls 来代替 self 其余自定义
多态: 著名的鸭子测试: 当我们看到一只鸟走起来像鸭子,游泳起来像鸭子,叫起来也像鸭子,那么这只鸟就可以被称为鸭子
意思是:一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前的方法属和属性的集合决定的。
注意: 类型检查是毁掉多态的利器 type() isinstance() issubclass() 慎用!
类的封装和私有化: 方法 或者属性 前面添加上 __ 即可 这样的话外部无法访问,但可以通过方法来访问
如果想在外部访问私有属性或方法前添加上 @property 可以直接访问 对象.属性
class Person:
__age = int()
def __init__(self,name):
self.name = name
self.__age = 10
@property #################这里可以直接访问到了
def age(self):
print(self.name,' 的年龄是:',self.__age)
特殊属性和方法:
1: dir(obj) 可以查看类的属性和方法 列表形式
2:__dict__
Class.__dict__['attribute'] dict 返回的是一个字典 里边包含类的属性和方法,调用 ['attribute'] 返回的是属性的值
如果对象实例化后也可以调用 dict 但是必须确保属性被赋值 被赋值的意思就是实例属性遮盖了类属性的值 可以考虑添加到 init 中
注意: 这里类属性和实例化属性的 dict 是分开的,互不干扰,除非被覆盖,一方添加新属性另一方不会访问到
如:class A(object):
age = '1' ## 这里的age 是类属性 实例永远无法修改
def __init__(self):
self.age = 2 ## 这里的age 是实例属性 可以修改 但是只是修改本实例的内容 方法也一样
def gaga(self):
pass
pass
3: __slots__ 能够限制属性的定义,终极目标是优化内存使用
首先 __slots__('A','a') 在实例化中也可以直接调用 __slots__ 来访问,这和__dict__ 正好相反 dict 必须实例化后赋值才可以
对于已经在类属性中赋值的,实例属性没有权利去修改,如果实例属性想修改的话可以 a.B = 'A值' 就是元组中值反过来修改
10: 文件系统
打开一个文件 open('文件位置名','x') x = r(只读) w(读写 新建一个文件) a(追加模式)
有关读写模式:
rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w 以写方式打开,
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
a = open() 获取的是一个文件属性集合 io.TextIOWrapper name='C:\\Users\\Administrator\\Desktop\\python\\1.txt' mode='r' encoding='cp936'
也有 len(a) 同时 a.tell() 返回读取的位置 调用 a.read() 才得到 str 的文件内容
a 实现的一些方法:
a.seek(8,0) # 将文件指针移动到指定位置 注意中文字符要占两个指针位置 file.seek(0,0) 返回开始
a.tell() 返回光标在文件的位置
a.readline() 返回一行 返回str
a.readlines() 返回所有行 返回 list
a.read() 返回所有内容 返回 strict
a.close() 注意文件使用后要关闭
a.write('写入内容') 返回写入长度 这里是写入文件方法
os 模块
1: 获取当前目录 str = os.getcwd()
2: print(os.listdir(path='D:\\Soft\\temp')) # 列举指定目录中的文件(不管是文件还是文件夹) . 当前目录 .. 上一目录
3:os.mkdir('123') # 在当前目录下创建文件夹 如已存在跑出异常 可以创建多层 \\
4:os.remove('D:\\Soft\\temp\\oui.txt')删除文件 os.rmdir('')删除单层目录 注意文件夹要空
5:os.rename('old','new') 文件重命名
泡菜模块 pickle 永久保存文件
import pickle,os
test_list = [1,2,3,'郭新杰',[4,5,6]]
pickle_file = open('test111','wb') #二进制保持 # 这里的 pkl 后缀 随便写 提醒作用
print(type(pickle_file))
print(pickle_file)
pickle.dump(test_list,pickle_file) # 利用泡菜将列表放入文件
pickle_file.close() # 不关掉的话还在缓冲区
file = open('C:\\Users\\Administrator\\Desktop\\python\\test111','rb')
test = pickle.load(file)
print(test)
if isinstance(temp,str):
2: 导入对象 import import 导入的是模块 模块的方法是内置函数
3: input('请输入') 获取键盘输入对象
4:随机数 import random
random.randint(1,10) 返回一个 1-10 内的随机数
5: 类型转换 转换对象+() m = int(m)
m = int() 意思就是 m = 0
6: 判断符号
+=,-=,*=,/=,%=,**=,<<=,>>=,&=,^=,|= 自变运算符 通常用于数字
<,<=,>,>=,==,<>,!= 比较运算符 通常用于字符串
7: 对象
列表 [] 符号分割 内置对象之间用 , 分割开来
普通列表 混合列表: m = [1,2,3,'23']
空列表: m = []
元素添加:append()
extend(list) 将一个列表添加到此列表对象内
insert(1,2) 1是下标位置 2是对象 如果下标超过len(list) 自动在列表后追加,否则插入指定位置,此位置后的元素均向后错位一位
元素删除:remove('参数名称') 注意 两个相同对象的列表 只能删除一个对象
del mem[1] 下标为1 的对象从列表中删除
del mem 从内存中删除整个列表
pop(1) 不加参数默认删除最后一个 加参数删除下标为参数内对象的对象
如果列表内有字符串,列表和数字组合的话,默认元素首尾是 " " 符号来表示一个列表元素
列表分片:为了一次性获取多条元素
list[1:2] 没有1 2 的话 默认获取列表所有元素
只有1 从1指定下标开始截至到列表结束内的元素
只有2 从0开始到下标为2 的元素集合
有1 和 2 从1 开始到2结束 不包括2 的元素集合
正向 反向索引 -1 表示最后一个元素 list2=list[-1:] 只获取最后一个元素
列表常用操作符:
< = > 比较的是列表的第一个元素的大小 = 号是相同的列表
* 列表相加 list1 * 3 = [123,345,123,345,123,345] 等同于三个字符串相加
in not in 函数 类似 java 的 contains 方法 返回 布尔类型值 注意 多层列表的话 无法判断 只能当层列表
count(obj) 元素在列表出现的次数
index(obj,1,2) 如果有1 2 参数的话 表示obj 在列表中从1开始到2结束内所在的位置
注意 这里只返回一个值,如果有多个相同的话是无法识别的
reverse 列表翻转
sort() 默认自动排序
逻辑操作符 and or
元组: 带上了枷锁的列表 和 str int flot list 一样 元组有自己的类型 tuple
定义元组后 内置的元素不可改变
元组创建:tuple = (1,2,3) 或者 tuple =1,2,3 注意 元组是以 () 来包围元素的 和 list 的 [] 不同
注意 元组中如果只有一个元素的时候,在此元素后加逗号避免歧义 tuple=(123,)
元组更新: 采用tuple[x:y] 方式分解元组 然后创建新的元组 tuple1+tuple2 即可成为新的元组
元组删除: del tuple
元组内置函数:1、cmp(tuple1, tuple2):比较两个元组元素。
2、len(tuple):计算元组元素个数。
3、max(tuple):返回元组中元素最大值。
4、min(tuple):返回元组中元素最小值。
5、tuple(seq):将列表转换为元组。
能用元组 最好不要用list 因为更安全
字符串:
capitalize() 把字符串第一个字符改为大写
casefold() 所有字符串改为小写
count("abc") abc 在字符串出现的次数
endswith("abc") 判断是否以 abc 结尾 注意 这里是区分大小写的
startswith("abc") 判断是否以 abc 开头
find("a") 判断a 是否在字符串内,有的话返回索引值 索引以 0 开头 如果没有的话 返回 -1
index("a") 和 find 一样 只不过没有字符串的话会返回异常
isalpha() 都是字母 返回 true
isalnum() 字符或数字 true
isdigit() 只包含数字 true
lover() 转换所有大写为小写
lstrip() 去掉左边空格
rstrip() 去掉尾部空格
strip() 删除字符串首尾两端所有空格
encode(encoding='utf-8',errors='strict') 指定编码格式进行编码
replace(old,new,count) new 替换 old count 指定的话替换不超过 count次哦
集合 set 从2.3 版本以后就可以不用导入set模块 符号:set([])
注意: 能用set 不要用 list
set 无序不重复的集合 并且支持 union(联合) intersection(交) difference(对称差集)
sets 支持 x in set, len(set) 和 for m in set:
作为一个无序集合,set 并不支持 indexing slicing 或其他类序列的操作
set 创建:x = set(['hello']) set元素不允许有 list 和tuple
注意 set 外面嵌套两层 内层是[] 外层是 () 哪怕只有一个元素也要两个符号都有 不然 交集 并集 差集无法实现
x & y 取交集
x | y 取并集
x - y 取差集 x有 y 没有
set 添加: add() 添加一条元素
update([1,2,3]) 添加多项元素 可以添加set list 元组 等别的数据类型
set 删除: remove(元素值) 可以删除一项
len(set) 长度 x in set 测试是否在set 里 in not in
boolean = x.issubset(y) 测试 x 中的每个元素是否都在 y里 返回 boolean
set = x.union(y) 返回新set 包含两个 x y 所有元素
x in y 测试 x 是否是y 的成员
为啥 x=set([1]) y=set([1,2,3,4,5] m = x in y print(m) 这里是False 但是 m 换成1 后就是Ture
注意 这里的x 为单独的一个元素 不能是set
x.issubset(y) x y 都是set sub后是爹 super 后是儿子
x.issuperset(y)
x.union(y) x y 集合所有元素
x.intersection(y) 包含x 和y 的公共元素
x.difference(y) x 有 y 没有的set 元素
字典:python 中唯一的映射类型
字典和序列类型的区别:存储和访问数据的方式不同
序列类型只用数字型的键(set除外),映射类型可以用其他对象类型做键,并且键值有一定的关系
映射数据无序排列
映射类型用键直接映射到值
字典的创建: adict = {} 一个大括号符号 或者 m = dict()
adict = {k1:value1,k2:value2,l3:value3}
两种创建方式: 1 maps = {'李宁':'一切皆有可能','耐克':'just do it','阿迪':'Impossible is nothing','特步':'非一般的感觉'}
2 maps = dict(特步='非一般的感觉',李宁='一切皆有可能') # 这里key 不允许用引号 会自动转换成字符串
注意: 键值分开 用: 区别
项与项 之间用 , 号 分开
字典中的键必须是唯一的,而值可以不唯一
keys() 打印出所有的key values() 打印出所有的值 items() 所有
字典的添加: dict[key] = value 更新一个值也是一样的
setdefault(5,'value') 随机添加一个字典内的键值对
dict.update(字典对象)
字典的删除: del dict[key] 删除某个键值对
del dict 删除整个字典
adict.clear() 删除字典中的所有项或元素
dict.pop(key) 删除 key 项并返回 key 对应的value
字典内键值判断:
in 或 not in 判断一个key 是否在字典key中
字典值得查询: dict.get(key) 获取 value 值
8: 函数 多参数,不定参数,多返回值,闭包 重点
def test():
代码块 调用函数的话 test() 注意:参数可以是任何数据类型 字符串 数字 浮点 列表 元组 集合 字典
参数: 形参 def test(obj) 这里 obj 就是形参 没有实际值
实参 test("obj") 这里 obj 就是实参
注意 调用的时候 多个参数可以在实参前加上形参名称
如 def demo(name,world):
print(name+world)
demo(world="改变世界",name="guoxinjie") 顺序不会改变
默认参数:定义了默认值的参数
def demo(name="guoxinjie",world="改变世界"):
print(name+world)
测试: demo(world="改变世界",name="guoxinjie")
搜集参数: 搞不清楚需要多少个参数 其实参数就是元组 注意 这里如果有固定参数的话 调用的时候 添加上默认参数就可以混用了
# 收集参数 通常情况下coder 并不知道需要多少个参数
def demo1(*params):
print("穿入参数个数: ",len(params));
print("第一个参数:"+params[1]);
demo1(1,"2",3,4,5)
多结果返回 返回结果是一个元组,这点功能大赞,是java比拟不了的 ***************
变量: python引用变量的顺序: 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量
函数变量的作用域:
局部变量:local Variable
全局变量:Global Variable java没有全局变量 只有实例变量 方法体外
在全局变量定义后 在函数内重新定义全局变量 python 会为该变量重新定义一个名称相同的变量,但是全局变量并不会被改变
内嵌函数: global 定义在函数内部的变量前,可以修改全局变量的值
lambda m = lambda x,y:(x+2)*y m(1,2) = 6 注意参数和表达式中间用 分号隔开
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
闭包: 一个闭包就是你调用了一个函数A,这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。
闭包是在一个function 上 return function 内部的 function2 注意 这里的 function2 不加括号的
如: def test1():
def test2():
print('11')
return '22'
return test2 ##这里反馈test2 函数 这里 test2 就是一个闭包
闭包可以被理解为一个只读的对象,你可以给他传递一个属性,但它只能提供给你一个执行的接口。因此在程序中我们经常
需要这样的一个函数对象——闭包,来帮我们完成一个通用的功能,比如后面会提到的——装饰器。
我们在编程时经常会把通用的东西抽象成类,(当然,还有对现实世界——业务的建模),以复用通用的功能。闭包也是一样,
当我们需要函数粒度的抽象时,闭包就是一个很好的选择。
工厂函数(factory function)
Python2.2统一了类型和类,所有的内建函数现在都也是类,在这基础上,原来的所谓的内建转换函数像int()、type()、list()等,现在都成了工厂函数。
虽然看上去像函数,但实质上它们是类,当你在调用它们时,实际上生成了该类的一个实例,就像工厂生产货物一样。
int()、long()、float()、complex()、str()、unicode()、basestring()、list()、tuple()、type()
dict()、bool()、set()、frozenset()、object()、classmethod()、staticmethod()、super()、property()、file()
内建函数(Built-in Functions),个人觉得就是自带的、标准的函数
9: 类和对象 一切皆对象 python 对象 = 属性+方法
注意打印语句 print('我叫%s,该死的谁踢我'% self.name) %s 表示需要打印的对象
类是对象的模板或蓝图,类是对象的抽象化,对象是类的实例化。类不代表具体的事物,而对象表示具体的事物。
class people: 注意 对象是没有() 只有方法函数才有():
类 默认打印方法 _str__(self): 打印对象的时候默认打印这个方法内的信息
默认初始化方法: __init__(self) 类初始化方法 里边传参来使用
zhangsan.speak()就好比写成了peo.speak(zhangsan) 这里self参数就会告诉方法是哪个对象来调用的.这称为实例引用、
注意: python 类创建后,setAttribute 和 .attribute 区别
通过重写构造方法来传入参数
类私有变量: 在类里变量前加上 __ 符号即可
类的继承: class test(基类) 或者 在类前添加 __metaclass__ = 基类
注意: 1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。有别于C#
2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。
(先在本类中查找调用的方法,找不到才去基类中找)
类或方法的文档 访问的
类的创建: 默认首字母大写
类的函数-- 必须有 self 作为第一个参数 ************************
def __init__ 初始化函数或者 构造函数 如果外面没参数的话,默认初始化在这里 def __init__(self,name='gg',age=12)
在 __init__ 中还可以添加属性让外部实例访问到但并不用在外部初始化
__init__(self): self.name = 'gg' p = Person() p.name = 'gg'
同时不但在 __init__ 中添加属性,在别的方法也可以,但是必须确保实例调用赋值所在的方法才可以访问到
类属性和实例属性:
类属性 -- 类的属性,不是独立的一个对象
实例属性 -- 类被实例化后的实际值 但是 类属性不会随着实例属性ongoin的改变而改变
class Person: x = 7 m = Person() m .x = 8 但是 Person.x =7 就是这个意思
实际上 m.x = 8 等于新建了一个属性,但是这个属性和原来的属性 Person.x 重名 于是Person.x 值被覆盖了,del m.x 后就出来了
但是 类的属性一定会影响到实例属性,类属性改变了,实例属性也会改变
有例外: 当类属性不是整数的时候,比如列表, 双方都会影响对方的
所以 不要轻易在实例属性修改类属性,这样的话实例化的其他对象都会受影响的
如果增加了类属性,实例属性一定会增加,但是增加了实例属性,类属性不受影响
注意: 如果在类中创建了成员变量,在该类的方法中是无法被访问到的,只有通过 __init__(self) 这个参数赋值后类方法才可以通过self 来使用
如果在类初始化中创建一个变量(或者类初始化的变量) 该变量在类中任何一个方法中被重新修改,那么无论是其他方法调用还是被实例化的
对象调用,这个变量的值都会随着改变而改变 下面我们看下他们的id是否改变,结果证实 ID 也会随着变化的。
之所以不推荐创建类的属性值 是因为这个是可变的,并且任何一处定义了都能改变值,维护非常困难,一般建议通过self 来传值
类的继承: inheritance
Object = Class(SuperClass)
注意: 子类中在对 __init__ 内的变量在其他任何方法上做修改,内外值都会随着改变
子类重写了父类的属性或者方法后,父类的信息都会改变
多重继承: class A classB c = classC(A,B) 顺序按照AB 顺序来
Super() 调用显示父类的属性或函数 在重写的时候调用可以延续父类的属性或方法,子类可选是否借用父类
格式为: super(父类,参数self).__init__() 父类函数
静态方法: 使用前提,需要一个参数不能让别人进行修改,在非特定环境下该静态变量或方法外部修改无效,只有在特定环境下修改才可行
如 IND = 'ON'
class Kls(object):
def __init__(self, data):
self.data = data
@staticmethod 表明这是一个静态方法
def checkind():
IND = "OFF" ### 只有在这里修改才有效
return (IND == 'ON') 在别的地方也可以修改这个值 但是在调用这个方法的时候 IND 始终是OFF (已修改) 不会再有别的值
def do_reset(self):
IND = 'OFF' ##这里修改无效
if self.checkind():
print('Reset done for:', self.data)
def set_db(self):
if self.checkind():
self.db = 'New db connection'
print('DB connection made for: ', self.data)
类方法: @classmethod 表示下面的方法是类方法 将类本身作为对象进行操作的方法
注意 必须至少有一个参数 cls 来代替 self 其余自定义
多态: 著名的鸭子测试: 当我们看到一只鸟走起来像鸭子,游泳起来像鸭子,叫起来也像鸭子,那么这只鸟就可以被称为鸭子
意思是:一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前的方法属和属性的集合决定的。
注意: 类型检查是毁掉多态的利器 type() isinstance() issubclass() 慎用!
类的封装和私有化: 方法 或者属性 前面添加上 __ 即可 这样的话外部无法访问,但可以通过方法来访问
如果想在外部访问私有属性或方法前添加上 @property 可以直接访问 对象.属性
class Person:
__age = int()
def __init__(self,name):
self.name = name
self.__age = 10
@property #################这里可以直接访问到了
def age(self):
print(self.name,' 的年龄是:',self.__age)
特殊属性和方法:
1: dir(obj) 可以查看类的属性和方法 列表形式
2:__dict__
Class.__dict__['attribute'] dict 返回的是一个字典 里边包含类的属性和方法,调用 ['attribute'] 返回的是属性的值
如果对象实例化后也可以调用 dict 但是必须确保属性被赋值 被赋值的意思就是实例属性遮盖了类属性的值 可以考虑添加到 init 中
注意: 这里类属性和实例化属性的 dict 是分开的,互不干扰,除非被覆盖,一方添加新属性另一方不会访问到
如:class A(object):
age = '1' ## 这里的age 是类属性 实例永远无法修改
def __init__(self):
self.age = 2 ## 这里的age 是实例属性 可以修改 但是只是修改本实例的内容 方法也一样
def gaga(self):
pass
pass
3: __slots__ 能够限制属性的定义,终极目标是优化内存使用
首先 __slots__('A','a') 在实例化中也可以直接调用 __slots__ 来访问,这和__dict__ 正好相反 dict 必须实例化后赋值才可以
对于已经在类属性中赋值的,实例属性没有权利去修改,如果实例属性想修改的话可以 a.B = 'A值' 就是元组中值反过来修改
10: 文件系统
打开一个文件 open('文件位置名','x') x = r(只读) w(读写 新建一个文件) a(追加模式)
有关读写模式:
rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w 以写方式打开,
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
a = open() 获取的是一个文件属性集合 io.TextIOWrapper name='C:\\Users\\Administrator\\Desktop\\python\\1.txt' mode='r' encoding='cp936'
也有 len(a) 同时 a.tell() 返回读取的位置 调用 a.read() 才得到 str 的文件内容
a 实现的一些方法:
a.seek(8,0) # 将文件指针移动到指定位置 注意中文字符要占两个指针位置 file.seek(0,0) 返回开始
a.tell() 返回光标在文件的位置
a.readline() 返回一行 返回str
a.readlines() 返回所有行 返回 list
a.read() 返回所有内容 返回 strict
a.close() 注意文件使用后要关闭
a.write('写入内容') 返回写入长度 这里是写入文件方法
os 模块
1: 获取当前目录 str = os.getcwd()
2: print(os.listdir(path='D:\\Soft\\temp')) # 列举指定目录中的文件(不管是文件还是文件夹) . 当前目录 .. 上一目录
3:os.mkdir('123') # 在当前目录下创建文件夹 如已存在跑出异常 可以创建多层 \\
4:os.remove('D:\\Soft\\temp\\oui.txt')删除文件 os.rmdir('')删除单层目录 注意文件夹要空
5:os.rename('old','new') 文件重命名
泡菜模块 pickle 永久保存文件
import pickle,os
test_list = [1,2,3,'郭新杰',[4,5,6]]
pickle_file = open('test111','wb') #二进制保持 # 这里的 pkl 后缀 随便写 提醒作用
print(type(pickle_file))
print(pickle_file)
pickle.dump(test_list,pickle_file) # 利用泡菜将列表放入文件
pickle_file.close() # 不关掉的话还在缓冲区
file = open('C:\\Users\\Administrator\\Desktop\\python\\test111','rb')
test = pickle.load(file)
print(test)
相关文章推荐
- python cookbook 学习笔记 -- 1.4 字符串对齐
- python的函数学习笔记
- Python学习笔记0002:判断正负数
- Web Scraping with Python 学习笔记7
- [Python]学习笔记之文件和异常
- Python-函数其他(学习笔记4)
- Python2.7 学习笔记1-列表
- 学习笔记——Python实现垃圾邮件过滤
- 极客 | Python | 学习笔记01:Python 定向爬虫入门
- Python学习笔记(二)网络编程的简单示例
- OpenCV学习笔记(六十二)——《OpenCV Computer Version with Python》阅读摘要
- python 学习笔记 字符串(2)
- Python学习笔记——字符串和整数
- Python学习笔记--2016.08.02
- Programming Computer Vision with Python (学习笔记十一)
- python学习笔记(三)高级特性
- [python]python学习笔记(四)
- 初学Python的学习笔记2----dist字典,set集合,声明函数,函数参数
- python学习笔记--3
- python学习笔记(2)序列的通用基本操作