Python学习,个人笔记,有点乱,不过比较全

时间:2022-05-06 00:31:12
1、bif -- build in function


2、列出bif : dir(__builtins__),大部分小写字母开头的是bif


3、temp = input("可显示参数:") 注意:raw_input()


4、查找bif的功能:help(bif)  例如:help(input)


5、原始字符创 str = r'C:\now' (相当于转义字符)


6、三重引号字符串:"""内容""" (自动补全换行符)


7、import random
random.randint(start, end) 例如random.randint(1,10)


8、type(object)
bool isinstance(object, int[str, float, ])


9、assert 的作用是什么?
  
assert这个关键字我们称之为“断言”,当这个关键字后边的条件为假的时候,程序自动崩溃并抛出AssertionError的异常。
什么情况下我们会需要这样的代码呢?当我们在测试程序的时候就很好用,因为与其让错误的条件导致程序今后莫名其妙地崩溃,不如在错误条件出现的那一瞬间我们实现“自爆”。
一般来说我们可以用Ta再程序中置入检查点,当需要确保程序中的某个条件一定为真才能让程序正常工作的话,assert关键字就非常有用了。


10、假设有 x = 1,y = 2,z = 3,请问如何快速将三个变量的值互相交换?
  答:x, y, z = z, y, x


11、Python 有一个成员资格运算符:in,用于检查一个值是否在序列中,如果在序列中返回 True,否则返回 False。


12、small = x if (x < y and x < z) else (y if y < z else z)


13、print(a, b, c)
print(string1 + string2)


14、for  目标 in 表达式:
循环体 


for i in "fishc":
print(i, end=' ')



member = ["小甲鱼","黑客"]
for each in member:
print(each, len(each))


15、range(5), range(2,5), range(2, 10, 2)
range(start, stop, step)


16、member = ["小甲鱼","黑客"]
member = []


17、member.append('甲鱼')  不等于  member.append(['甲鱼'])


18、member.extend(['甲鱼', '大傻'])


19、member.insert(位置, 元素)


20、member.remove('huangjinhua')
del member[2]
member.pop(0)
member.pop()
member[1:3]指member[1]和member[2]
member[:3]指member(0-2)
member[1:]指从1开始
member[:]指member的拷贝:member2=member[:]


21、list1 = [123,[456, 789]]
123 in list1 (True)
456 in list1 (False)
[456, 789] in list1 (True)
456 in list1[1] (True)


22、dir(list)
listobject.count(元素):返回元素在列表中出现的次数
listobject.index(元素):返回元素第一次出现位置
listobject.index(元素,start,end):start\end是指索引,如3,8, 指搜索范围


listobject.reverse():反转
listobject.sort():从小到大
listobject.sort(reverse=False):默认参数
listobject.sort(reverse=True):从大到小


list1 = list2[:] :复制, == list1 = list2.copy()
list1 = list2 :别名,改变其中一个,另一个同样改变,实际上是同一个东西,相当于C改变地址指向的值

27、[i*i for i in range(6)]  :[0,1,4,9,16,25]
== [i**2 for i in range(10)]
== list1 = []
  for i in range(10):
list1.append(x**2)


28、list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]


29、list2 = list1.copy()
== list2 = list1[:]


30、list.clear()


31、list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]
相当于:
list1 = []

for x in ragne(10):
for y in range(10):
if x%2 == 0:
 
if y%2 != 0:
list1.append((x, y))


32、>>> list3 = [name + ':' + slogan[2:] for slogan in list1 for name in list2 if slogan[0] == name[0]]


33、tuple元组
temp = ()
temp = (1,) 不等于temp(1),前者tuple,后者int


8*(8)  == 64
2*(2,) == (2,2,2,2)


34、temp = ("小甲鱼","黑夜","迷途","小布丁")
temp = temp[:2] + ("宜静",) + temp[2:]#此句执行后,temp 指向 新对象, 就对象找不到了,将被回收
  == temp = ("小甲鱼","黑夜","宜静","迷途","小布丁")


35、del temp :temp为tuple类型


36、str1 = "I love fishc.com"
str1 = str1[:6]+"要添加\插入的字符串"+str1[6:]
修改则要过滤修改的位置


37、序列:列表、元组、字符串


38、strobject.capitalize():把字符串的第一个字符改写为大写
casefolf():吧整个字符的所有字符串改为小写
center(width):将字符串居中,并使用空格填充至长度width的新字符串
count(sub[, start[, end]]):返回在字符串里出此案的次数
encode(encoding='utf-8', errors='strict'):以endcoding制定的编码格式对字符串进行编码
endswith(sub[,start[,end]]):检查字符串是否以sub子字符串结束,如果是返回True,否则返回False。start和end参数表示范围,可选。
expandtabs([tabsize=8]) :把字符串中的tab符号(\t)转换为空格,如不指定参数,默认的空格数是tabsize=8。
find(sub[,start[,end]]):检测sub是否包含在字符串中,如果有则返回索引值,否则返回-1,start和end参数表示范围,可选。
rfind(sub[,start[,end]]) #类似于find()方法,不过是从右边开始查找。
index(sub[,start[,end]]):  跟find方法一样,不过如果sub不在string中会产生一个异常。
rindex(sub[,start[,end]]) #类似于index()方法,不过是从右边开始。
isalnum():如果字符串至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False。
isalpha():如果字符串至少有一个字符并且所有字符都是字母则返回True,否则返回False。
isdecimal(): 如果字符串只包含十进制数字则返回True,否则返回False。
isdigit() #如果字符串只包含数字则返回True,否则返回False.
islower() #如果字符串中至少包含一个区分大小写的字符,并且这些字符都是小写,则返回True,否则返回False。
isupper() #如果字符串中至少包含一个区分大小写的字符,并且这些字符都是大写,则返回True,否则返回False。
isnumeric() #如果字符串中只包含数字字符,则返回True,否则返回False。
isspace() # 如果字符串中只包含空格,则返回True,否则返回False。
istitle() #  如果字符串是标题化(所有的单词都是以大写开始,其余字母均小写),则返回True,否则返回False。
join(sub) #以字符串作为分隔符,插入到sub中所有的字符之间。
ljust(width) #返回一个左对齐的字符串,并使用空格填充至长度为width的新字符串。
rjust(width) #
lower() #转换字符串中所有大写字符为小写。
upper() #
partition(sub) #找到子字符串sub,把字符串分成一个3元组(pre_sub,sub,fol_sub),如果字符串中不包含sub则返回(‘原字符串’, ’’, ’’)
rpartition(sub) #
replace(old,new[,count]) # 把字符串中的old子字符串替换成new子字符串,如果count指定,则替换不超过count次。
strip([chars]) #删除字符串前边和后边所有的空格,chars参数可以定制删除的字符,可选。
rstrip() #删除字符串末尾的空格。
split(sep=None, maxsplit=-1) #不带参数默认是以空格为分隔符切片字符串,如果maxsplit参数有设置,则仅分隔maxsplit个子字符串,返回切片后的子字符串拼接的列表。
swapcase() # 翻转字符串中的大小写。
title() #返回标题化(所有的单词都是以大写开始,其余字母均小写)的字符串。
zfill(width) #返回长度为width的字符串,原字符串右对齐,前边用0填充




39、"{0} love {1}.{2}".format("I", "Fishc", "com")


"{a} love {b}.{c}".format(a="I", b="Fishc", c="com")
"{0} love {b}.{c}".format("I", b="Fishc", c="com")


40、转义花括号:"{{0}}".format("打印花括号")
"{0}".format("不打印花括号")


41、"{0:.1f}{1}".format(27.689, "GB")


42、格式化字符串%:
"%c" % 97
"%c %c %c" % (97, 98, 99) //元组()


temp = "i love you"
"%s" % temp


'%d + %d = %d' % (4, 5, 4+5)

'%o' % 10


'%x' % 10
'%X' % 10


定点数 :'%f' % 1.234 
'%.2f' % 1.234
科学计数法: '%e' % 1.234
'%E' % 1.234
智能根据大小使用%f或%e: '%g' % 1.234
'%G' % 1.234


43、
字符串格式化符号含义
  
   符   号
   说     明
     %c
   格式化字符及其ASCII码
     %s
   格式化字符串
     %d
   格式化整数
     %o
   格式化无符号八进制数
     %x
   格式化无符号十六进制数
     %X
   格式化无符号十六进制数(大写)
     %f
   格式化定点数,可指定小数点后的精度
     %e
   用科学计数法格式化定点数
     %E
   作用同%e,用科学计数法格式化定点数
     %g   根据值的大小决定使用%f活%e
     %G
   作用同%g,根据值的大小决定使用%f或者%E
  
  
44、格式化操作符辅助指令
                                                 
   符   号
    说     明
      m.n m是显示的最小总宽度,n是小数点后的位数 :"%10d" % 5
      
- 用于左对齐 :"%-10d" % 5
      
+ 在正数前面显示加号(+)
       
# 在八进制数前面显示 '0o',在十六进制数前面显示 '0x' 或 '0X' : "%#o" % 10
       
0 显示的数字前面填充 '0' 取代空格 : "%010d" % 5




45、字符串转义字符含义
  
   符   号
    说     明
       \'
    单引号
       \"
    双引号
       \a
    发出系统响铃声
       \b
    退格符
       \n
    换行符
       \t
    横向制表符(TAB)
       \v
    纵向制表符
       \r
    回车符
       \f
    换页符
       \o
    八进制数代表的字符
       \x
    十六进制数代表的字符
       \0
    表示一个空字符
       \\
    反斜杠


46、file = open("C:\\windows\\temp\\readme.txt", "r")
file1 = open(r'C:\windows\temp\readme.txt', 'r')


47、. 有字符串:str1 = '<a href="http://www.fishc.com/dvd" target="_blank">鱼C资源打包</a>',请问如何提取出子字符串:'www.fishc.com'
>>> str1[-45:-32] 或 >>> str1[16:29]


48、>>> str1[20:-36]:显示fishc (负号只表示从尾部开始倒着数)


49、 据说只有智商高于150的鱼油才能解开这个字符串(还原为有意义的字符串):str1 = 'i2sl54ovvvb4e3bferi32s56h;$c43.sfc67o0cm99'
>>> str1[::3]


50、>>> p = dict([('clock',12),('table', 100),('xiao', 100)])
    >>> p
{'clock': 12, 'table': 100, 'xiao': 100}


51、函数名称只是一个变量,一个对象。记得‘一切都是对象’。所以可以向普通对象一样,把函数名称赋值给另一个变量。myadd = add,这点有点像函数指针。术语叫function alias,函数别名.


52、buildin functions:
1、将ASCII码转换为对应的字符 chr(90) == 'Z'
  将字符转换为对应的ASCII码 ord('Z') == 90


2、str, dict, tuple, list

3、cmp(a,b),divmod(a,b)


4、hex(a), oct(a)


5、int, long, float


6、input, raw_input


7、len, max, min


8、filter, map, sum, zip, reduce


9、pow(a,b) == a**b,  abs, all, any


10、range, xrange, round


53、源代码:python 源文件.py


字节代码:-Python源文件经编译后生成的扩展为“pyc”的文件;
 -编译方法:import py_compile
   py_compile.compile("hello.py")


优化代码
-经过优化的源文件,扩展名为“.pyo”
-python -O -m py_compile hello.py


54、id(a):查看a变量的地址


55、1<<1:移位
a << b :将a左移b位


56、>>> nail = """Now:
you know
you are nothing
"""
>>> nail
'Now:\nyou know\nyou are nothing\n'
>>> print nail
Now:
you know
you are nothing


57、>>> m = "1234567890"
>>> k=2
>>> l=9
>>> n=2
>>> m[k:l:n]
'3579'
>>> m[::3]
'1470'
# 切片 :起始k,终止l,每n个取一个


58、m[-4:-2:-1] # 从后往前一个一个地取


59、重复序列元素:"#"*5 == "#####"


60、str1 = "abc"
"a" in str1 :成员操作符 ( not in)


61、str2 = "12345" #用到max,min时,实际上这里序列str2被当作迭代器
max(str2)
min(str2)


62、cmp(a,b):比较两个序列 :== 0
    > 1
    < -1


63、单一元素元组:s = (2,)#注意要逗号, 区别s=(2)


64、>>> t = ("nobody", 21, "female")
>>> name,age,gender=t
>>> name
'nobody'
>>> age
21
>>> gender
'female'
# a,b,c=1,2,3  == a,b,c=(1,2,3) 其实一样的,前者不规范,都是元组


65、序列(元组,列表,字符串)均可以切片


66、列表(list)操作:
-取值
切片和索引
list[]
-添加
list.append()
-删除
del(list[])
list.remove(list[])
-修改
list[] = x
-查找
var in list


67、help(list.append)


68、>>> t = ['name', 'age', 'gender']
>>> t2 = ['no', 30, 'female']
>>> zip(t, t2)
[('name', 'no'), ('age', 30), ('gender', 'female')]


69、字典是python中唯一的映射类型(哈希表)
字典是可变的,但是字典的键必须使用不可变对象,并且一个字典中可以使用不同类型的键值
keys()或values()返回键列表或值列表
items()返回包含键值对的元组


70、创建字典:
-{} 例、dic={0:0, 1:1, 2:2}
-使用工厂方法dir()
例: fdict=dict(['x',1], ['y',2])
-内建方法: fromkeys(), 字典中的元素具有相同的值,
默认为None
例: ddict = {}.fromkeys(('x','y'), -1)


71、访问字典中的值:
-循环遍历:
例: for key in dict1.keys():
-使用迭代器:
for key in dict1:


72、字典的更新和删除:
-直接用键值访问更新:内奸的update()方法可以将整个字典的内容拷贝到另一个字典中
-del dict1['a']删除字典中键值为a的元素
dict1.pop('a')删除并且返回键值为'a'的元素
dict1.clear()删除字典中的所有元素
del dict1 删除整个字典


73、字典增加:
dict1['tel'] = 12343643


74、dic.get(3[, 'error'])


75、>>> a = xrange(10) #产生迭代器
>>> a
xrange(10)
>>> for k in a:
print k


76、for x in dict1:
print x #键 for x in dict1.keys()
print dict1[x] #值 for x in dict1.values()


for k, v in dict1.items()
print k
print v
else:
print "ending" #正常结束才会执行else


77、函数传递实参、形参;默认形参;参数位置对应

78、linux中文(utf8)编码编码(windows :gbk):#coding:utf8
 #coding=utf8
 #encoding:utf8
 #encoding=utf8
 #-*- coding:utf8 -*-


79、局部变量和全局变量:
全局变量和局部变量名相同(意义完全不同)时,全局变量不能改变局部变量的值
用global a强制将局部变量声明为全局变量


80、return 返回值;函数调用后默认返回None


81、True if x > y else false
1 if x > y else (0 if x==y else -1)


82、def f(x,y)
print x, y
    t = (1,2) # 元组
    f(*t) # 元组传值
    dict1 = {'a':1, 'b':2}
    f(**dict1) #字典传值


83、函数处理多余的参数:
def fun(*args, **kw)




84、lambda :
匿名函数-lambda函数是一种快速定义但行的最小函数,是从lisp借用来的,可以用在任何需要函数的地方
例:def f(x,y):return x*y  ==  g=lambda x,y:x*y #lambda返回一个函数对象
f(x,y) == g(x,y)


85、reduce为逐次操作list里的每项,接收参数为两个,最后返回一个结果
>>> def myadd(x,y):
return x+y
>>> sum = reduce(myadd,(1,2,3))
>>> sum
6
>>>sum = reduce(lambda x,y:x+y,[1,2,3])


86、 >>> a = list("love")
>>> a
['l', 'o', 'v', 'e']
>>> reduce(lambda x,y:x+y, a)
'love'
>>> 


87、switch语句:python无switch语句,但是python 可以通过字典实现switch语句的功能
实现方法:
-首先,定义一个字典
-其次,调用字典的get()获取相应表达式
例:{1:case1,2:case2}.get(x, lambda *arg, **key:)()


#!/usr/bin/python
#coding:utf-8


from __future__ import division #自动使用浮点数除法 5/2=2.5


x = 1
y = 2
operator = {
'+':x+y, 
'-':x-y, 
'*':x*y, 
'/':x/y
}


print operator.get("/")




88、内置函数
divmod(x,y) #求两个数的的商和模,(x/y, x%y)
pow(x,y) == x**y #pow(x,y, z) == x**y %z
round() #return float
callable(function object) :测试函数是否能被调研
isinstance()
cmp()
range() 、 xrange()

type()
int()
long()
float()
complex()


str()
list()
tuple()
hex()
oct()
chr() #ASCII
ord() #ASCII


89、str.capitalize()
str.replace(old, new[, count])
str.split(sub[,count]) #切割 
例:>>>ip = "192.168.1.123"
  >>>ip.split('.')
  ['192', '168', '1', '123']


>>> import string
>>> string.replace(ip, '1', 'x')
'x92.x68.x.x'


90、序列处理函数:
filter() #过滤
zip()
map()
reduce()
例:>>> def f(x):
if x>3:
return True


   >>> filter(f, [1,2,3,4,5,6])
   [4, 5, 6]
   >>> 
>>> filter(lambda x:x>3, [1,2,3,4,5,6])
[4, 5, 6]
>>> name = ['huang', 'gao', 'no']
>>> age = [21,20,00]
>>> tel = [661503, 621688, 911]
>>> reduce(zip, (name, age, tel))
[(('huang', 21), 661503), (('gao', 20), 621688), (('no', 0), 911)]
>>> reduce(zip, name)
[(('h', 'g'), 'n'), (('u', 'a'), 'o')]
>>> zip(name, age, tel)
[('huang', 21, 661503), ('gao', 20, 621688), ('no', 0, 911)]
>>> map(None, name, age, tel)
[('huang', 21, 661503), ('gao', 20, 621688), ('no', 0, 911)]
>>> test = ['a', 'b']
>>> zip(name, age, tel, test)
[('huang', 21, 661503, 'a'), ('gao', 20, 621688, 'b')]
>>> map(None, name, age, tel, test)
[('huang', 21, 661503, 'a'), ('gao', 20, 621688, 'b'), ('no', 0, 911, None)]
>>> a = [1,3,5]
>>> b = [2,4,6]
>>> map(None,a,b)
[(1, 2), (3, 4), (5, 6)]
>>> map(lambda x,y:x*y,a,b)
[2, 12, 30]
>>> reduce(lambda x,y:x*y, range(1,6)) #阶乘
>>> reduce(lambda x,y:x*y, xrange(1,6))


91、模块module:
if __name__ == __main__   # __main__ 、 cal
operator(1, '/', 3)


92、包(package):
-建名字为包名字(packagename)的文件夹
-在该文件家下将一个__init__.py文件 #__init__.py包含包信息
-根据需要在该文件夹下存放脚本文件、已编译扩展及子包
-import packagename.m1, packagename.m2


93、>>> import os as pwd
>>> pwd.getcwd()
'/home/me/'
>>> from os import getcwd
>>> getcwd()
'/home/me/'


94、re module:(正则表达式):
元字符:^  $  {} [] \ * + -
s = r"^abc":以abc开头
s = r"a[bc]":含ab或ac
s = r"a[^bc]"#不含ab或ac
s = r"a[bc^]"#元字符不起作用,取含ab或ac或a^
s = r"a[bc$]" #同上
s = r"abc$" #以abc结尾

95、s = r"^abc"  t = "^abc^abc"
    s = r"\^abc" t = "^abc ^abc" #转义字符\
转义字符:
  s = r"\d" #\d单个数字
  re.findall(s, "123456789")


\d #匹配任何十进制数,相当于[0-9]
\D #匹配任何非数字字符,相当于[^0-9]
\s #匹配任何空白字符,相当于[\t\n\r\f\v]
\S #匹配任何非空白字符,相当于[^\t\n\r\f\v]
\w #匹配任何字母数字字符:相当于类[a-zA-Z0-9]
\W #匹配任何非字母数字字符:相当于[^a-zA-Z0-9]



96、r = r"^010-\d{8}" #匹配八+3位号码 #{8}指重复八次

97、重复-正则表达式的第一个功能是能匹配不定长得字符集,
-另一个功能是可以指定正则表达式的一部分重复次数

* #指定前一个字符可以被匹配零次或多次,而不是只有一次。
 #匹配引擎会试着重复尽可能多的次数(不能超过整数界定范围, 20亿)
例如:a[bcd]*b -- "abcbd"


+ #表示匹配一或更多次
 #注意 * 和 + 之间的不同,*匹配零次或更多次,所以可以更本不出现,而+则要求至少出现一次


?#匹配一次或零次; 你可以认为它用于标事物是可选的


例如:r = r"010-?\d{8}$"
r = r"ab+" #贪婪模式,最大匹配
r = r"ab+?" #最小匹配 
{m,n} #至少重复m次,至多重复n次
      {0,} == *
{1,} == +
{0,1} == ?


98、类和对象 : 类:是对事物的抽象,对象是累的一个实例
  python类定义
类的属性
类的方法


99、python类的定义:
使用class关键字定义一个类,并且类名首字母要大写;
当程序员需要创建的类型不能用简单类型表示额时候就需要创建类;
类把需要的变量和函数组合在一起,这种包含也称之为“封装”


100、python类的结构:
class 类名(首字母大写):
成员变量
成员函数


101、类的方法中至少有一个参数self


102、对象的创建:
创建对象的过程称之为实例化;当对象被创建后,包含三个属性:对象的句柄、属性和方法
句柄用于区分不同的对象
对象的属性和方法与类中成员变量和成员函数对应
if __main__== "__main__":
myClass1 = MyClass #创建类的一个实例对象


103、对实例的对象的属性重新赋值;对实例的对象添加属性


104、python对象的体系结构:
-经典对象:内部的属性和方法组成,属性可以是数据类型也可以是函数类型。如属性为函数则该属性就是一个方法。
类的内部方法-python类当中提供了一些内部方法名,方法名由前后两个下划线加字母组成。例如python的
     构造函数__init__。(init前后均为两个下划线)
-新型对象:定义新型对象,必须继承object方法 class_name(object)
新型对象提供了对类方法和静态方法的支持。


105、类的属性:
 类由属性和方法组成,类的属性是对数据的封装,类的方法则是对类的行为的封装。类的属性按
使用范围分为公有属性和私有熟悉,类的属性范围取决于属性的名称。
-公有属性:就是在类中和类外调用的属性
-私有属性:不能被类以外的函数调用
(可以通过instance.__classname__attribute方式访问,但只用于调试程序)
定义方式:以“__”双下划线开始的成员变量就是私有属性,否则为公有属性
-内置属性:由系统在定义类的时候默认添加的,由前后两个下划线构成
__dict__,__module__


106、Python的属性按类别分为实例属性(对象属性)和静态属性(类属性)两种:
实例属性:是以self作为前缀的属性,实例属性定义在__init__方法中。如果__init__中德变量没有self,则变量只是一个普通的局部变量.
例如:
class Myclass:
var1 = 0 #类属性
def __init__(self):
self.var2 = 0 #实例属性
Vars3 = 0 #局部变量
类的属性:可以被类,以及实例对象访问,定义在类中的变量都是类的外部属性不能直接访问私有属性,私有属性之你呢个被类本身访问,例如:
class Myclass():
var1 = "类属性,也叫静态属性"
__var2 = "类的私有属性"
def __init__(self):
self.var2 = "var2是实例的属性"
self.__var3 = "实例的私有属性"
var4 = "简单变量,非属性,作用域只在函数体内"


107、方法的定义:
和函数定义一样,但需要self作为第一个参数
     类的方法分为:公有方法和私有方法
私有方法:不能被外部的类和方法调用,但是可背类的内部方法调用。私有方法的定义和私有属性的定义都是一样的。在方法前面加上"__"就可以了
类方法(动态的):被classmethod()函数处理过的函数,能被类所调用,也能被对象所调用(是继承的关系);
静态方法:相当于“全局函数”,可以被类直接调用,可以被所有实例化对象共享,通过staticmethod()定义静态方法没有"self"语句;
     self参数:
用于区分函数和类的方法(必须有一个self),self参数表示指向对象本身


例如:装饰器:
@classmethod #动态方法(也叫类方法),动态加载所需的类属性和方法
def mori(self):
print "哈哈"
@staticmethod #静态方法,一掉用就自动加载全部类属性和方法,占有内存大
def mr:
printf "haha"



108、 Python对象高级
-内部类与魔术方法


内部类:就是在类的内部定义的类,主要目的是为了更好的抽象现实世界,
     一般不赞同使用内部类,会使程序结构复杂,但是理解内部类有助于理解模块的调用
内部类的实例化方法:
方法1、直接使用外部类调用内部类
object_name = outclass_name.inclass_name()
方法2、先对外部类进行实例化,然后再实例化内部类
out_name = outclass_nam()
in_name = out_name.inclass_name()
in_name.method()


魔术方法: def __str__(self):
return "我是实例化对象"




109、构造函数、析构函数:、
构造函数:用于初始化类的内部状态,Python提供的构造函数是__init__();
__init__()方法是可选的,如果不提供,Python会给出一个默认的__init__()方法;
一般对数据的获取需要自定义的get和set方法;
析构函数:用于释放对象占用的资源,Python提供的析构函数是__del__();
__del__()也是可选的,如果不提供,则Python会在后台提供默认的析构函数;
如果要显式的调用析构函数,可以使用del关键字,方式如下:
del 对象名


110、垃圾回收机制:
 Python采用垃圾回收机制来清理不再使用的对象;Python提供gc模块释放不再使用的对象Python采用"引用计数"的计算方法;来
处理回收,即当某个对象在其作用域内不再被其他对象引用的时候,Python就自动清理对象;
Python的函数collect()可以一次性手机所有带处理的对象(gc.collect())


111、 常用的内置方法:




(Python面向对象——继承、多态、重载)
112、类间关系:
 当多个类被设计完成时,一般都会有类与类之间的相互关系‘
 类之间存在继承、组合、依赖等关系;
 继承是面向对象的重要特性之一;
继承关系:继承是相对于两个类而言的父子关系,子类继承了父类的所有公有属性和方法;
继承实现了代码的重用;


113、使用继承:
 继承可以重用已经存在的数据和行为,减少代码的重复编写。Python在类名后
使用一对括号来表示继承关系,括号中的类即为父类;
格式:
Class Myclass(ParentClass):
注意:
如果父类定义了__init__方法,子类必须显示调用父类的__init__方法("BaseClass.__init__(self[,args...])").
如果子类需要扩展父类的行为,可以添加__init__方法的参数;


114、Python支持多重继承,即一个类可以继承多个父类;
多重继承语法格式:
Class_name(parent_class1, parent_class2...)
注意:
 当父类中出现多个自定义的__init__方法时,多重继承只执行第一个类的__init__方法,其他不执行;






115、MySQLdb:
(1、mysql -uroot -ppasswd
2、show database;)


1、(引入MySQL类)import MySQLdb
2、(获取连接对象)conn = MySQLdb.connect(user='root',passwd='',host='127.0.0.1')
3、(创建游标的对象)cur = conn.cursor()
4、(增加删除数据)conn.select_db('database_name')

5、(SQL语句)cur.execute(query语句)
query语句:
@1、create table tab_name( 
   id int(10) not null auto_increment primary key, 
   name varchar(40), 
   pwd varchar(40) 
           ) charset=gb2312; 创建一个名为tab_name的新表
@2、create database db_name                //新建一个数据库名称
drop database da_name                  //删除一个数据库名称
use db_name                            //打开一个数据库名称    
create table                           //新建一个表的名称
primary key                            //设置主键  
create table new_tb_name select * from table_name //建立一个内容完全相同的表
drop table tb_name                     //删除一个表名


alter table                            //改变表的结构
alter table tb_name RENAME new_tb_name //改变表的名称
alter table tb_name change 字段名 字段名 字段类弄(长度) //修改字段名
alter table tb_name modify 字段名  字段类弄(长度)       //修改字段类型
alter table tb_name add column 字段名 字段类型(长度)    //增加一个字段名
alter table tb_name add index(字段名)                   //增加一个索引
alter table tb_name add primary key(字段名)            //设主键
alter table tb_name drop column 字段名                  //删除列
INSERT INTO语句 //插入数据
insert into tb_name values(值1,值2,值3...)
insert into tb_name (字段名1,字段名2,字段名3...)  values (值1,值2,值3...)
insert into tb_name set 
                    字段名=值1,
                    字段名=值2,
                    字段名=值3
                     .
                     .
                     .
UPDATE语句 //修改数据
update tb_name set 
                  字段名=值1
                  字段名=值2,
                  字段名=值3
                     .
                     .
                        where (条件)         
DELETE语句 //修改数据
delete from tb_name where (条件)


SELECT语句 //查询数据
select (条件) from 表名 WHERE (条件)  //select now();
select 字段名1,段名2... from 表名 WHERE (条件)
select * from 表名
select * from 表名 order by 字段名 //排序




6、请注意一定要有conn.commit()这句来提交事务,要不然不能真正的插入数据。


7、(查询)cur.execute('select * from table_name')
cur.fecthone()
cur.fetchall()
cur.fetchmany(self,size=None)
cur.scroll(0,'absolute') #类似移动指针
8、查询后中文会正确显示,但在数据库中却是乱码的。注意这里要添加一个参数charset:
在Python代码 
conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python') 中加一个属性:
 改为:
conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python',charset='utf8') 
charset是要跟你数据库的编码一样,如果是数据库是gb2312 ,则写charset='gb2312'。

9、我采用的是MySQLdb操作的MYSQL数据库。先来一个简单的例子吧:
importMySQLdb
try:
    conn=MySQLdb.connect(host='localhost',user='root',passwd='root',db='test',port=3306)
    cur=conn.cursor()
    cur.execute('select * from user')
    cur.close()
    conn.close()
exceptMySQLdb.Error,e:
     print"Mysql Error %d: %s"%(e.args[0], e.args[1])
请注意修改你的数据库,主机名,用户名,密码。
下面来大致演示一下插入数据,批量插入数据,更新数据的例子吧:
importMySQLdb
try:
    conn=MySQLdb.connect(host='localhost',user='root',passwd='root',port=3306)
    cur=conn.cursor()
    cur.execute('create database if not exists python')
    conn.select_db('python')
    cur.execute('create table test(id int,info varchar(20))')
    value=[1,'hi rollen']
    cur.execute('insert into test values(%s,%s)',value)
    values=[]
    fori inrange(20):
        values.append((i,'hi rollen'+str(i)))
    cur.executemany('insert into test values(%s,%s)',values)
    cur.execute('update test set info="I am rollen" where id=3')
    conn.commit()
    cur.close()
    conn.close()
exceptMySQLdb.Error,e:
     print"Mysql Error %d: %s"%(e.args[0], e.args[1])
请注意一定要有conn.commit()这句来提交事务,要不然不能真正的插入数据。
运行之后我的MySQL数据库的结果就不上图了。
importMySQLdb
try:
    conn=MySQLdb.connect(host='localhost',user='root',passwd='root',port=3306)
    cur=conn.cursor()
    conn.select_db('python')
    count=cur.execute('select * from test')
    print'there has %s rows record'%count
    result=cur.fetchone()
    printresult
    print'ID: %s info %s'%result
    results=cur.fetchmany(5)
    forr inresults:
        printr
    print'=='*10
    cur.scroll(0,mode='absolute')
    results=cur.fetchall()
    forr inresults:
        printr[1]
    conn.commit()
    cur.close()
    conn.close()
exceptMySQLdb.Error,e:
     print"Mysql Error %d: %s"%(e.args[0], e.args[1])
查询后中文会正确显示,但在数据库中却是乱码的。注意这里要添加一个参数charset:
在Python代码 
conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python') 中加一个属性:
 改为:
conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python',charset='utf8') 
charset是要跟你数据库的编码一样,如果是数据库是gb2312 ,则写charset='gb2312'。
备注:python mysql链接常用函数
commit() 提交
rollback() 回滚
cursor用来执行命令的方法:
callproc(self, procname, args):用来执行存储过程,接收的参数为存储过程名和参数列表,返回值为受影响的行数
execute(self, query, args):执行单条sql语句,接收的参数为sql语句本身和使用的参数列表,返回值为受影响的行数
executemany(self, query, args):执行单挑sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数
nextset(self):移动到下一个结果集


cursor用来接收返回值的方法:
fetchall(self):接收全部的返回结果行.
fetchmany(self, size=None):接收size条返回结果行.如果size的值大于返回的结果行的数量,则会返回cursor.arraysize条数据.
fetchone(self):返回一条结果行.
scroll(self, value, mode='relative'):移动指针到某一行.如果mode='relative',则表示从当前所在行移动value条,如果 mode='absolute',则表示从结果集的第一行移动value条.




SOCKET SECTION
116、socket([family[,type[,proto]]]) -> socket object
family:socket.AF_INET(ipv4)
type: socket.SOCK_STREAM(tcp)
     socket.SOCK_DGRAM(udp)
proto:


117、socket服务器实现:
socket对象:
bind()
listen()
accept()
send()
recv()
close()


118、建立服务器的过程(4部):
1、建立socket对象
2、设置socket选项
3、绑定到一个端口
4、侦听连接


host = '127.0.0.1'
port = 51423


#Step 1(Create the socket object)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


#Step 2(Set the socket options)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)


#Step 3 (Bind to a port and interface)
s.bind((host, port))


#Step 4(Listen for connections)
s.listen(5)


119、建立客户端:
#!/usr/bin/python
#coding:utf8


import socket
import time


host = '127.0.0.1'
port = 9999


c = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


cs = c.connect((host, port))
print cs


while True:
    x = raw_input("Me: ")
    c.send(x)
    print "Serve: ", c.recv(1024)
    time.sleep(1)


120、#!/usr/bin/python
#coding:utf-8
#Get list of available socket options


import socket
solist = [x for x in dir(socket) if x.startswith('SO_')]
solist.sort()
for x in solist:
    print x




121、