不可变对象
Python中一切皆对象，每一个对象都有一个唯一的标示符（id()）、类型（type()）以及值。对象根据其值能否修改分为可变对象和不可变对象，其中数字、字符串、元组属于不可变对象，字典以及列表、字节数组属于可变对象
字符串属于不可变对象，任何对字符串的直接修改都会报错
那怎么修改呢？通过 array 来进行
'''
修改字符串，引入array模块
'''
a = "nihao"
import array
b = array.array('c', a) # 注意第一个参数必须是 'c'
# 然后将b按照字符串来修改
b[3] = 'a'
b.tostring() # 即可转换位字符串
==经常遇到的错误==
class Student(object):
def __init__(self,name,course=[]): # 这里传参有问题！！
self.name=name
self.course=course
def addcourse(self,coursename):
self.course.append(coursename)
def printcourse(self):
for item in self.course:
print item
stuA=Student("Wang yi")
stuA.addcourse("English")
stuA.addcourse("Math")
print stuA.name +"'s course:"
stuA.printcourse()
print "-----------------------"
stuB=Student("Li san")
stuB.addcourse("Chinese")
stuB.addcourse("Physics")
print stuB.name +"'s course:"
stuB.printcourse()
运行结果
Wang yi's course:
English
Math
-----------------------
Li san's course:
English
Math
Chinese
Physics
这是由于 init 函数第二个参数是默认参数，m默认参数在被调用的时候只初始化一次。所以两个对象的 course 是同一个值
列表推导式
比如实现如下代码：
words = [' Are', ' abandon', 'Passion','Business',' fruit ','quit']
size = len(words)
newlist = []
for i in range(size):
if words[i].strip().istitle():
newlist.append(words[i])
print newlist
功能比较简单，就是遍历 words 中的每一个元素，然后判断首字母是不是大写
如果用列表推导式：
words = [' Are', ' abandon', 'Passion','Business',' fruit ','quit']
newlist = [ i for i in words if i.strip().istitle()]
很快就能完成
多重嵌套
>>> nested_list = [['Hello', 'World'], ['Goodbye', 'World']]
>>> nested_list = [[s.upper() for s in xs] for xs in nested_list]
>>> print nested_list
[['HELLO', 'WORLD'], ['GOODBYE', 'WORLD']]
>>>
xs 是一个list，再对xs中的每一个字符串进行操作
多重迭代
>>> [(a,b) for a in ['a','1',1,2] for b in ['1',3,4,'b'] if a != b]
[('a', '1'), ('a', 3), ('a', 4), ('a', 'b'), ('1', 3), ('1', 4), ('1', 'b'), (1,
'1'), (1, 3), (1, 4), (1, 'b'), (2, '1'), (2, 3), (2, 4), (2, 'b')]
>>>
做笛卡尔积， 去掉元素值相等的元组
使用函数
>>> def f(v):
... if v%2 == 0:
... v = v**2
... else:
... v = v+1
... return v
...
>>> [f(v) for v in [2,3,4,-1] if v>0] #
表达式可以是函数
[4, 4, 16]
>>> [v**2 if v%2 ==0 else v+1 for v in [2,3,4,-1] if v>0]#
也可以是普通计算
[4, 4, 16]
>>>
任何可迭代对象都是可以的
fh = open("test.txt", "r")
result = [i for i in fh if "abc" in i] #文件句柄可以当做可迭代对象
print result
函数传参
如下例子中，甚至可以直接将一个列表推导式作为参数传入其中
>>> def foo(a):
... for i in a:
... print i
...
>>> foo([1, 2, 3])
1
2
3
>>> foo(i for i in range(3) if i % 2 == 0)
0
2
字典推导式
互换 key 和 value
person = {'name':'xiaobai','city':'paris'}
person_reverse = {v:k for k,v in person.items()} #简单互换key和value的值即可
再看一个复杂点的栗子：统计字母(不分大小写)出现的次数
nums = {'a':10,'b':20,'A':5,'B':3,'d':4}
num_frequency = {k.lower():nums.get(k.lower(),0) + nums.get(k.upper(),0)
for k in nums.keys() } # 注意 get方法中第二个参数是指定的默认值
print(num_frequency)
字典推导式配合枚举：将list转换位dict
fruit = ['apple','organge','banana','mango','peach']
fruit_positon = {v:i for i,v in enumerate(fruit)}
print(fruit_positon)
Out: {'apple': 0, 'organge': 1, 'banana': 2, 'mango': 3, 'peach': 4}
集合推导式
返回人名
names = [ 'Bob', 'JOHN', 'alice', 'bob', 'ALICE', 'James', 'Bob','JAMES','jAMeS' ]
names_standard = { n[0].upper()+n[1:].lower() for n in names}
print(names_standard)
Out: {'John', 'Bob', 'James', 'Alice'}
综合运用：统计一个文本中的单词长度大于5并且倒过来也有意义
with open('dictionary.txt') as dictionary_file:
words = (line.rstrip() for line in dictionary_file)
words_over_five_letters = [w for w in words if len(w)>5 ]
reversed_words ={
word[::-1]
for word in words_over_five_letters
}
reversible_words = [
word
for word in words_over_five_letters
if word in reversed_words
]
for word in reversible_words[0:20]:
print(word)
函数是如何传参的
先下结论：函数的传参既不是传值也不是传引用，更不是有时候传值有时候传引用
def change_me(org_list):
print id(org_list)
new_list = org_list
print id(new_list)
if len(new_list)>5:
new_list = ['a','b','c']
for i,e in enumerate(new_list):
if isinstance(e,list):
new_list[i]="***" #将元素为list类型的替换为***
print new_list
print id(new_list)
test1 = [1,['a',1,3],[2,1],6]
change_me(test1)
print(test1)
test2=[1,2,3,4,5,6,[1]]
change_me(test2)
print(test2)
运行结果：
64172232
64172232
[1, '***', '***', 6]
64172232
[1, '***', '***', 6]
64121928
64121928
['a', 'b', 'c']
64018440
[1, 2, 3, 4, 5, 6, [1]]
第一个测试可以说是传引用，但是第二个测试却变成了传值
当org_list的长度大于5的时候，new_list =['a','b','c']操作重新创建了一块内存并将new_list指向它。当传入参数为test2=[1,2,3,4,5,6,[1]]的时候，函数的执行并没有改变该列表的值
因此，对于Python函数参数是传值还是传引用这个问题的答案是：都不是。正确的叫法应该是传对象（call by object）或者说传对象的引用（call-by-object-reference）。函数参数在传递的过程中将整个对象传入，对可变对象的修改在函数外部以及内部都可见，调用者和被调用者之间共享这个对象，而对于不可变对象，由于并不能真正被修改，因此，修改往往是通过生成一个新对象然后赋值来实现的。
默认参数
默认参数可能带来的问题已经在 不可变对象 阐述过了
>>> def appendtest(newitem,lista = []): #默认参数为空列表
... print id(lista)
... lista.append(newitem)
... print id(lista)
... return lista
...
>>>
>>> appendtest('a',['b',2,4,[1,2]])
39644216
39644216
['b', 2, 4, [1, 2], 'a']
>>>
def在Python中是一个可执行的语句，当解释器执行def的时候，默认参数也会被计算，并存在函数的.func_defaults属性中。由于Python中函数参数传递的是对象，可变对象在调用者和被调用者之间共享，因此当首次调用appendtest(1)的时候，[]变为[1]，而再次调用的时候由于默认参数不会重新计算，在[1]的基础上便变为了[1,'a']。我们可以通过查看函数的func_defaults来确认这一点。
变长参数
*args 和 **kwargs 代表了变长参数
一个简单地示例：
def SumFun(*args):
result = 0
for x in args[0:]:
result += x
return result
print SumFun(2,4)
print SumFun(1,2,3,4,5)
print SumFun()
变长参数带来的问题：
def set_axis(x,y, xlabel="x", ylabel="y", *args, **kwargs):
pass
以下调用方式都是对的：
set_axis(2,3, "test1", "test2","test3", my_kwarg="test3")
①
set_axis(2,3, my_kwarg="test3")
set_axis(2,3, "test1",my_kwarg="test3")
②
set_axis("test1", "test2", xlabel="new_x",ylabel = "new_y", my_kwarg="test3")
set_axis(2,"test1", "test2",ylabel = "new_y", my_kwarg="test3")
静态方法和类方法
类方法实例：统计实例化了多少个对象
思路：每次实例对象的时候必然会调用 __init__ 方法，
class Kls(object):
num_inst = 0
def __init__(self):
Kls.num_inst = Kls.num_inst + 1 # 每实例化一个对象变量的值就会+1
@classmethod
def get_no_of_instance(cls):
return cls.num_inst
ik1 = Kls()
ik2 = Kls()
print ik1.get_no_of_instance() # 输出2
print Kls.get_no_of_instance() # 输出2
书上提到的一个类方法栗子：
class Fruit(object):
total = 0
@classmethod
def print_total(cls):
print cls.total
#print id(Fruit.total)
#print id(cls.total)
@classmethod
def set(cls, value):
#print "calling class_method(%s,%s)"%(cls,value)
cls.total = value
class Apple(Fruit):
pass
class Orange(Fruit):
Pass
app1 = Apple()
app1.set(200)
app2 = Apple()
org1 = Orange()
org1.set(300)
org2 = Orange()
app1.print_total() #output 200
org1.print_total() #output 300
但是上面例子中的类方法修改为实例方法也是可以的，并没有多大的影响
同时我们可以看下面这个三种方法得对比：
class A(object):
def instance_method(self,x):
print "calling instance method instance_method(%s,%s)"%(self,x)
@classmethod
def class_method(cls,x):
print "calling class_method(%s,%s)"%(cls,x)
@staticmethod
def static_method(x):
print "calling static_method(%s)"%x
a = A()
a.instance_method("test")
#输出calling instance method instance_method(<__main__.A object at 0x00D66B50>,test)
a.class_method("test")
#输出calling class_method(<class '__main__.A'>,test)
a.static_method("test")
#输出calling static_method(test)
调用实例方法的时候：
[图片上传失败...(image-790e53-1582298210229)]
调用类方法的时候
[图片上传失败...(image-f2734b-1582298210229)]
浅拷贝和深拷贝
这一段代码，模拟了一个客户到披萨点点餐
import copy
# 披萨店
class Pizza(object):
def __init__(self,name,size,price):
self.name=name
self.size=size
self.price=price
def getPizzaInfo(self):
#①获取Pizza相关信息
return self.name,self.size,self.price
def showPizzaInfo(self):
#②显示Pizza信息
print "Pizza name:"+self.name
print "Pizza size:"+str(self.size)
print "Pizza price:"+str(self.price)
def changeSize(self,size):
self.size=size
def changePrice(self,price):
self.price=price
# 具体的订单
class Order(object):
#③订单类
def __init__(self,name):
self.customername=name
self.pizzaList=[]
self.pizzaList.append(Pizza("Mushroom",12,30))
def ordermore(self,pizza):
self.pizzaList.append(pizza)
def changeName(self,name):
self.customername=name
def getorderdetail(self):
print "customer name:"+self.customername
for i in self.pizzaList:
i.showPizzaInfo()
def getPizza(self,number):
return self.pizzaList[number]
customer1=Order("zhang") # 新客户 zhang
customer1.ordermore(Pizza("seafood",9,40))
customer1.ordermore(Pizza("fruit",12,35))
print "customer1 order infomation:"
customer1.getorderdetail()
print "-------------------------------"
此时又来了一个顾客，订单和客户1一样，只是要将预定的水果披萨的尺寸和价格进行相应的修改，于是为了方便直接拷贝了客户1的订单
customer2=copy.copy(customer1) # 注意此处是浅拷贝
print "order 2 customer name:"+customer2.customername
customer2.changeName("li")
customer2.getPizza(2).changeSize(9)
customer2.getPizza(2).changePrice(30)
print "customer2 order infomation:"
customer2.getorderdetail()
print "-------------------------------------"
客户2的订单完成了，但是你会发现客户1的订单也被改变了
[图片上传失败...(image-ac75be-1582298210229)]
浅拷贝并没有复制 pizza ，导致两份订单中的 pizza 指向同一块内存地址
换成 copy.deepcopy 就没问题了
python字符串
多行字符串技巧
>>> a = ('aaaa'
... 'bbbbb'
... 'ccccc'
... 'ddddd'
... 'eeeee') # 遇到未闭合的小括号会将所有的字符串连在一起
>>> a
'aaaabbbbbcccccdddddeeeee'
性质判定
isalnum()、isalpha()、isdigit()、islower()、isupper()、isspace()、istitle()、startswith(prefix[,start[, end]])、endswith(suffix[,start[, end]])
查找和替换
count( sub[, start[, end]])、find( sub[, start[,end]])、index( sub[, start[, end]])、rfind( sub[, start[,end]])、rindex(sub[, start[, end]])
注意find()和index()方法的不同：find()函数族找不到时返回-1，index()函数族则抛出ValueError异常。
但是对于判定是否包含字串的判定推荐用 in 和 not in操作符
replace(old, new[,count])用以替换字符串的某些子串，如果指定count参数的话，就最多替换count次，如果不指定，就全部替换
分切与连接
partition() 和 split
split 举例：
>>> ' hello world'.split()
['hello', 'world']
>>> ' hello world'.split(' ') # 要注意第一种方式和第二种方式不一样
['', 'hello', '', '', '', '', 'world']
>>> ' hello world'.split('')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: empty separator
>>> ''.split()
[]
>>> ''.split(' ')
['']
变形
lower()、upper()、capitalize()、swapcase()、title()
删减与填充
strip([chars])、lstrip([chars])、rstrip([chars])
center(width[, fillchar])、ljust(width[,fillchar])、rjust(width[, fillchar])、zfill(width)、expandtabs([tabsize])
这些方法中的fillchar参数是指用以填充的字符，默认是空格。而zfill()中的z是指zero，所以顾名思义，zfill()即是以字符0进行填充，在输出数值时比较常用。expandtabs()的tabsize参数默认为8，它的功能是把字符串中的制表符（tab）转换为适当数量的空格。
异常处理
基本语法：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
如果 try 中发生了异常，那么根据发生的异常进入到 except 语句块中
之后如果没有异常发生，那么 try 完成之后进入 else 语句块
[图片上传失败...(image-8318d9-1582298210229)]
