1.*args,**kwargs的使用
def test(a,*args,**kwargs):
print a
print args
print kwargs
test(1,2,3,d='4',e=5)
output:
1
(2, 3)
{'e': 5, 'd': '4'}
分析:
自动分配
"1"是参数a的值
args是其他的值
kwargs是键值对
*args,**kwargs都是可变参数。
*args表示任何多个无名参数,是一个tuple
**kwargs表示关键字参数,是dict,
其中*args参数必须要在**kwargs参数的前面
2.lambda的使用
lambda的语法是唯一的。其形式如下:
lambda argument_list: expression
简介:
lambda函数相当于匿名函数。
lambda函数有输入和输出:输入是传入到参数列表argument_list的值,输出是根据表达式expression计算得到的值。
lambda函数一般功能简单,通常一行。
lambda:None;函数没有输入参数,输出是None
lambda **kwargs: 1;输入是任意键值对参数,输出是1
lambda x, y: xy;函数输入是x和y,输出是它们的积xy
3.文件的操作
python的内置函数
一、文件操作的流程:
#1. 打开文件,得到文件句柄并赋值给一个变量
#2. 通过句柄对文件进行操作
#3. 关闭文件
具体步骤如下:
f=open('test.txt',encoding='utf-8') #打开文件
data=f.read() #文件操作
print(data)
print(f.readlines()) #读取多行
print(f.readline()) #读取一行
f.close() #关闭文件
说明:
read 读取整个文件
readline 读取下一行
readlines 读取整个文件到一个迭代器以供我们遍历(读取到一个list中,以供使用,比较方便)、
二、open()函数的具体用法:
open函数最常用的使用方法如下:文件句柄 = open(‘文件路径’, ‘模式’,编码方式)。
1、关于文件路径
#文件路径:主要有两种,一种是使用相对路径,想上面的例子就是使用相对路径。
#另外一种就是绝对路径,像’ C:/Users/shu/Desktop/python/test.txt’
2、关于打开模式:
# r 以只读方式打开文件。这是默认模式。文件必须存在,不存在抛出错误
#rb 以二进制格式打开一个文件用于只读。
#r+ 打开一个文件用于读写。文件指针将会放在文件的开头。读完就追加。
#w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
#w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
#a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
#a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
注:后面有带b的方式,不需要考虑编码方式。有带+号的,则可读可写,不过它们之间还是有区别的
#原来文件内容是:
自恐多情损梵行,入山又怕误倾城.世间安得双全法,不负如来不负卿.
1.只读模式r:
f=open('test.txt','r')
data=f.read()
print(data) #自恐多情损梵行,入山又怕误倾城.世间安得双全法,不负如来不负卿.
f.close()
2.只写模式,w (存在会覆盖原来内容)
f=open('test.txt','w')
f.write('作者:仓央嘉措')
f.close() #写完后原来的内容全都不见了,只剩下'作者:仓央嘉措'.
3、追加模式,a
f=open('test.txt','a')
f.write('作者:仓央嘉措')
f.close() #写完内容如下:自恐多情损梵行,入山又怕误倾城.世间安得双全法,不负如来不负卿.作者:仓央嘉措
4、以r+模式打开
f=open('test.txt','r+')
f.write('作者:仓央嘉措')
print(f.read()) # 输出为" ,入山又怕误倾城.世间安得双全法,不负如来不负卿."
f.close()
#写完内容为 “ 作者:仓央嘉措,入山又怕误倾城.世间安得双全法,不负如来不负卿.”
#为什么输出和写完内容会这样呢? 解释这个只要知道紧跟光标的位置就可以明白了。
首先,以r方式打开光标都会在最开始的位置,这时候执行f.write('作者:仓央嘉措') ,这时候就把原来的‘自恐多情损梵行’覆盖了。这时候光标移动到','之前,
紧接着进行print(f.read())。就会把后面剩下的文本内容打印出来。所以输出就是:" ,入山又怕误倾城.世间安得双全法,不负如来不负卿." 整个程序完成后,
整个文本内容就成了;“ 作者:仓央嘉措,入山又怕误倾城.世间安得双全法,不负如来不负卿.”(光标!!)
3、关于编码方式:
#1.win系统默认是gbk编码的,所以桌面生成的TXT之类的都是gbk编码的。
#2.出现乱码正常都是原文件的编码方式和打开指定的编码不一致所致
三、关闭文件:
不要小看这一步,因为我们读取文件是把文科读取到内存中的,如果我们没关闭它,它就会一直占用系统资源,而且还可能导致其他不安全隐患。还有一种方法可以让我们不用去特意关注关闭文件。那就是 with open()
with open('test.txt','a+') as f:
f.write('作者:仓央嘉措')
print(f.read())
4.enumerate的用法
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
Python 2.3. 以上版本可用,2.6 添加 start 参数。
语法
enumerate(sequence, [start=0])
参数
sequence – 一个序列、迭代器或其他支持迭代对象。
start – 下标起始位置。
返回值
返回 enumerate(枚举) 对象。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
普通的 for 循环:
>>>i = 0
>>> seq = ['one', 'two', 'three']
>>> for element in seq:
... print i, seq[i]
... i +=1
output:
0 one
1 two
2 three
for 循环使用 enumerate
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
... print i, element
output:
0 one
1 two
2 three
5.break和continue的用法
1.break 结束循环
count = 0
while count < 10:
print('hello,Jay', count)
break
count = count+1
这段代码的运行结果是,只会打印了一遍“hello,Jay”。因为遇到break后,将结束循环,break后和循环体内的语句都不会被执行了。
2.continue 跳出本次循环,在所在的循环体中,再次重头循环
count = 0
while count < 10:
print('hello,Jay', count)
continue
count = count+1
这段代码的效果将会是一个死循环,它会一直打印“hello,Jay”.因为count永远都不能等于10,每次打印,代码到达continue都会再次从while循环开始执行。
6.strip和split用法
strip():strip()函数只对字符串的头和尾起作用
1.无参数时,strip()则把空格,tap等空字符删除。(strip())
2.有参数时,则把字符串中参数对应的字符串删除。(strip(‘a’))
>>> a = ' 123'
>>> a
' 123'
>>> a.strip()
'123'
>>> a = '123abc'
>>> a.strip('21')
'3abc'
>>> a.strip('12')
'3abc'
结果相同。
split():
1.无参数时,默认按所有的空字符。(split())
2.有一个参数时,则按照参数对应的字符分割。(split(‘a’))
3.有两个参数时,则按照参数对应的字符分割数次。(aplit(‘a’, 1))
str = (' www.google.com www.baidu.com ')
print(str)
str_split = str.strip()
print(str_split)
str_split = str.split()
print(str_split)
str_split = str.split(' ')
print(str_split)
str_split = str.split('.')
print(str_split)
str_split = str.split('.',1)
print(str_split)
output:
www.google.com www.baidu.com
www.google.com www.baidu.com
['www.google.com', 'www.baidu.com']
['', '', 'www.google.com', 'www.baidu.com', '']
[' www', 'google', 'com www', 'baidu', 'com ']
[' www', 'google.com www.baidu.com ']
7.filter()的使用
filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
语法:filter(function, iterable)
8.继承、__init__初始化、super的使用
1、继承
在Python中,同时支持单继承与多继承,语法如下:
class SubClassName(ParentClass1 [, ParentClass2, ...]):
class_suite
子类使用内建函数insubclass()来判断一个类是不是另一个类的子孙类:
class Parent(object):
numList = []
def numdiff(self, a, b):
return a-b
class Child(Parent):
pass
c = Child()
#子类继承父类的属性
Child.numList.extend(range(10))
print(Child.numList)
print("77 - 2 =", c.numdiff(77, 2))
print(issubclass(Child, Parent))
print(issubclass(Child, object))
#bases属性查看父类
print('the bases are:',Child.__bases__)
#doc属性不会被继承
print(Parent.__doc__)
print(Child.__doc__)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
77 - 2 = 75
True
True
the bases are: (<class '__main__.Parent'>,)
parent class
None
唯一特别的地方是文档字符串。文档字符串对于类,函数/方法,以及模块来说是唯一的,
也就是说doc属性是不能从父类中继承来的。
2.继承中的_ init _
如果子类没有定义自己的初始化函数,父类的初始化函数会被默认调用,实例化子类的对象时只能传入父类的初始化函数对应的参数,否则会出错
如果子类定义了自己的初始化函数,而在子类中没有显示调用父类的初始化函数,则父类的属性不会被初始化,在子类中显示调用父类,子类和父类的属性都会被初始化
2.1、子类没有定义自己的初始化函数,父类的初始化函数会被默认调用,实例化子类的对象时只能传入父类的初始化函数对应的参数,否则会出错:
#定义父类:Parent
class Parent(object):
def __init__(self, name):
self.name = name
print("create an instance of:", self.__class__.__name__)
print("name attribute is:", self.name)
#定义子类Child ,继承父类Parent
class Child(Parent):
pass
#子类实例化时,由于子类没有初始化,此时父类的初始化函数就会默认被调用
#且必须传入父类的参数name
c = Child("init Child")
#c = Child() 没有传入父类name参数的输出结果会报错
output:
create an instance of: Child
name attribute is: init Child
2.2、如果子类定义了自己的初始化函数,而在子类中没有显示调用父类的初始化函数,则父类的属性不会被初始化
class Parent(object):
def __init__(self, name):
self.name = name
print("create an instance of:", self.__class__.__name__)
print("name attribute is:", self.name)
#子类继承父类
class Child(Parent):
#子类中没有显示调用父类的初始化函数
def __init__(self):
print("call __init__ from Child class")
#将子类实例化
c = Child()
print(c.name) #在子类中没有显示调用父类的初始化函数,则父类的属性
#不会被初始化,因而此时调用子类中name属性不存在:
2.3、如果子类定义了自己的初始化函数,显示调用父类,子类和父类的属性都会被初始化
class Parent(object):
def __init__(self, name):
self.name = name
print("create an instance of:", self.__class__.__name__)
print("name attribute is:", self.name)
class Child(Parent):
def __init__(self):
print("call __init__ from Child class")
super(Child,self).__init__("data from Child") #要将子类Child和self传递进去
d = Parent('qiqi')
c = Child()
print(c.name)
output:
#实例化父类Parent的结果
create an instance of: Parent
name attribute is: qiqi
#实例化子类Child的结果
call __init__ from Child class
#super首先会先使得父类初始化的参数进行实例化
create an instance of: Child
name attribute is: data from Child
data from Child
3、super的使用详解
有时候可能需要在子类中访问父类的一些属性,可以通过父类名直接访问父类的属性,当调用父类的方法是,需要将”self”显示的传递进去的方式:
class Parent(object):
Value = "Hi, Parent value"
def fun(self):
print("This is from Parent")
class Child(Parent):
Value = "Hi, Child value"
def fun(self):
print("This is from Child")
Parent.fun(self) #调用父类Parent的fun函数方法
c = Child()
c.fun()
output:
This is from Child
This is from Parent
这种方式有一个不好的地方就是,需要经父类名硬编码到子类中,为了解决这个问题,可以使用Python中的super关键字:
class Parent(object):
Value = "Hi, Parent value"
def fun(self):
print("This is from Parent")
class Child(Parent):
Value = "Hi, Child value"
def fun(self):
print("This is from Child")
#Parent.fun(self)
super(Child,self).fun() #相当于用super的方法与上一调用父类的语句置换
c = Child()
c.fun()
This is from Child
This is from Parent
9.python的属性、方法和内置方法
1、对象的创建
创建对象的过程称之为实例化;当一个对象被创建后,包含三个方面的特性:对象句柄、属性和方法。
obj=MyClass() //创建类的一个实例(对象)通过对象来调用方法和属性
2、类的属性
类的属性按使用范围:公有属性和私有属性,
类的属性范围取决于属性的名称。
公有属性:在类中和类外都能调用属性。
私有属性:不能在类外及被类意外的函数调用。
定义方式:以“_”双下划线开始的成员变量就是私有属性
私有属性,可以通过instance._classname_attribute方式访问。
内置属性:有系统在定义类的时候默认添加的,由前后双下划线构成,dict,module.
3、类的方法
方法的定义和函数一样,但是需要self作为第一个参数
类的方法为:
公有方法:在类中和类外都能调用的方法
私有方法:不能被类外部调用,在方法前面加上“__“双下划线就是私有方法;
类方法:被classmethod()函数处理过的函数,能被类所调用,也能被对象所调用(是继承的关系)
静态方法:相当于“全局函数”,可以被类直接调用,可以被所有实例化对象共享,通过staticmethod()定义, 静态方法没有“self”参数。
装饰器:
- @classmethod
- @staticmethod
装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。
对象通过提供call(slef, [,*args [,**kwargs]])方法可以模拟函数的行为,如果一个对象x提供了该方法,就可以像函数一样使用它,也就是说x(arg1, arg2…) 等同于调用x.call(self, arg1, arg2)