1,避免‘\n’等特殊字符的两种方式：

1，利用转义字符‘\’

2，利用原始字符‘r’   print r‘c:\now‘

3,字符串中嵌入双引号等特殊符号

1，利用转义字符‘\’

2，使用单引号括起这个字符串    print (‘i l"o"ve fis.com‘)

2,跨越多行的字符串。使用三个‘‘‘........‘‘‘

4，条件分支：

if condition:

条件为真执行的操作

else:

条件为假执行的操作

if condition:

action

elif condition:

action

else:

action

python可以有效避免“悬挂else”（if else对应关系出错）

条件表达式（三元操作符）

small = x if x<y else y

如果x<y ,small=x.否则small=y

断言assert：当这个关键字后面的条件为假，程序自动崩溃并抛出异常

assert 3>4

可以利用他置入检查点

5，while条件:

条件为真执行的操作

   for 目标 in 表达式：

循环体

    例：favorite=‘fishc‘

for i in favorite:

print(i,end=‘‘)

   range([start,] stop[,step=1])

生成一个从start参数的值到stop参数值的数字序列

   break：终止当前循环体。跳到外层程序

   continue:终止本轮循环，开始下一轮循环（if condition true）

6，and逻辑操作符可以将任意表达式连接在一起，并得到一个布尔类型值

7，引入外援:

1，random模块

2，randint(),返回一个随机的整数

import random 或 from random import randint()

secret=random.randint(1,10)

8，python数据类型

1，数值类型:整型、布尔类型、浮点型、e记法（1.5e10）

2，类型转换：

int()转换为整数

str()转换为字符串

float()转换为浮点数

3，获取关于类型的信息：

type()函数

a=520

type(a)

isinstance()函数

a=12

isinstance(a,int)  --->返回true

isinstance(a,str)  -->返回false

9，Python值常用操作符

+ - * / % **（幂运算） //(地板除法,结果偏小)

   比较操作符   > < >=  <= 

   逻辑操作符   and  or  not

优先级：

幂运算**

正负号 + -

算术操作符   * / // 

+ -

比较操作符   < > =

逻辑擦作福   not and or

10,列表-->可以把整数、浮点数、字符串等打包在一起。数组却不能

创建一个普通列表：

member = [‘小甲鱼‘,‘小布丁‘,‘黑夜‘]

创建一个混合列表：

mix=[1,‘小甲鱼‘，3.12，[1,2,3]]

创建空列表：

empty=[]

向列表添加元素：

append():   member.append(‘福禄娃‘)-->只能添加一个。末尾添加

extend():   member.extend([‘test‘,‘test1‘])-->只能以列表形式添加.末尾添加

insert():   member.insert(1,‘牡丹‘)-->第一位插入牡丹

列表中获取元素： 使用索引index。   mix[1]

列表中删除元素： 使用remove（）。  mix.remove(‘小甲鱼‘)

使用del。   del mix[3]/mix

使用pop().   mix.pop()/mix.pop(1)

列表切片： 使用slice。   mix[1:4]/mix[1:]/mix[:4]

列表操作符： >,and,+,*,in/not in

列表的小伙伴： dir(list)

mix.count(‘小甲鱼‘)

mix.index(‘小甲鱼‘)  

列表逆序： 使用reverse。     mix.reverse()

列表排序： 使用sort。        mix.sort()

mix.sort(func,key)

mix.sort(reverse=True)

11,元组--->不可改变的列表

    和列表的主要不同点：

1，创建和访问一个元组： 大部分用（）/, ；列表用[]

2，元组不可修改数值

3，更新和删除一个元组：temp = temp[:2] + (‘test3‘,) + temp[2:]

del temp

4，IN/NOT IN，关系操作符，逻辑操作符，乘号操作符，连接操作符

12，字符串的各种内置方法

str1=‘i love fishc.com‘

a=str1[:6] + ‘插入的字符串‘+str1[6:]

capitalize()：    str2.capitalize()

casefold()--->全部小写   str2.casefold()

center(width)-->居中，不足空格填充

count(sub[,start[,end]])-->返回sub在string中出现的次数

endswith(sub[,start[,end]])-->以sub结束？

startswith(prefix[,start[,end]])-->以prefix开头

expandtabs([tabsize=8])-->将tab键转换为空格

find(sub[,start[,end]])-->sub是否在字符串中出现

rfind(sub)...

index(sub[,start[,end]])-->跟sub一样，不过会产生异常

rindex(sub..).....

istitle()/isupper()/ljust(width)/lower()/strip()/title()/lower()

join(sub):以字符串做分隔符，分割sub

partion(sub):找到子字符串sub，把字符串分成一个3元组

replace(old,new[,count])

split(sep=none,maxsplit=-1)-->不带参数以空格做分隔符

swapcase()-->字符串大小写翻转

zfill(width)-->返回长度为width的字符串，不够补充空格

13，字符串格式化 replacement

"{0} love {1}.{2:.2f}".format("i","fishc",3.1424)

"{a} love {b}.{c}".format(a="i",b="fishc",c="com")

"{0} love {b}.{c}".format("i",b="fishc",c="com")

格式化符号含义

%c:格式化字符及其ASCII码

‘%c %c %c‘ % (97,98,99)

%s:格式化字符串

%d:格式化整数

%o:格式化无符号八进制数

%x:格式化无符号十六进制数     %X:...(大写)

%f:格式化定点数，可指定小数点后的精度

%e:用科学技术发格式化定点数===%E

%g:根据值的大小决定使用%f或%e===%G

格式化操作符辅助命令

m.n ：m是显示的最小总宽度，n是小数位精度

- ：用于左对齐

+ ：在正数面前添加正号

# ：在八进制面前显示0，在十六进制面前显示0x

0 ：空格用0填充

字符串转义字符

\a:发出系统响铃声

\b、\t、\n

.....

14,序列

列表、元组和字符串的共同点：

都可以通过索引

索引值从零开始

内置方法：

list（）     ——>help-->转换为序列

list()

a=list()

list(iterable)

b=‘i love fishc.com‘

b=list(b)

tuple([iterable])-->把一个可迭代对象转换为元组

b=tuple(b)

str(obj)-->把obj对象转换为字符串

len(obj)-->返回obj的长度

max(序列/元组) /  min(序列/元组)

sum(iterable[,start=0])-->返回序列iterable。。的总和

sorted(序列/元组)-->排序

reversed(序列/元组)-->返回一个迭代器对象

list(reversed(序列/元组))-->返回序列

enumerate(序列/元组)-->返回一个迭代器对象

list(enumerate(序列/元组))-->返回数组形式列表

zip（a,b）-->合并成以元组形式的列表

list(zip(a,b))

15，函数

定义：def Myfunction():

print(‘this is my first function‘)

调用：Myfunction()

函数的参数：

def Myfunction(name,age):

print(name+age+‘test‘)

Myfunction(‘gncao‘，‘age’)

函数的返回值:

return  value

形参（parameter）：函数定义时的参数

实参（argument）：实际传递的参数

函数文档：在函数中实现

在函数体中用 ‘‘ 或 #

查看函数文档:    1， functionname.__doc__   （四个下划线）

2， help(functionname)

关键字参数：避免参数出乱

def Myfunction(words,name):

...

Myfunction(words=‘words123‘,name=‘name123‘)

默认参数:

def Myfunction(name=‘name123‘,words=‘words123‘)

...

收集参数：在参数前面加上*号

def test(*params):

print(‘参数的长度是:‘,len(params))

print(‘第二个参数是:‘,params[1])

test(1,‘小甲鱼‘,2,4,5,6,7)

def test(*params,exp):

print(‘参数的长度是:‘,len(params),exp)

print(‘第二个参数是:‘,params[1])

test(1,‘小甲鱼‘,23,4,2,5,7,exp=0)

16,函数有返回值，过程没有返回值

17，函数变量作用域（可见性）

局部：local-->函数内部定义的变量，局部可用

全局：global-->全局可访问

当在函数内部试图修改全局变量时，则会在函数内部新建一个跟 全局变量名相同的局部变量

18，内嵌函数和闭包

global关键字：

def myfun():

global count    ->>>全局变量

count=10

print(count)

内嵌函数:

def fun1():

print(‘fun1()正在被调用...‘)

def fun2():

print(‘fun2()正在被调用‘)

fun2()

只能通过fun1()访问fun2()

闭包:在一个内部函数中，对外部函数的变量的引用。成内部函数为闭包

def funx(x):

def funy(y):

return x * y

return funy

调用方式:

i=funx(8)

i(5)

或

funx(4)(5)

通过关键字nonlocal可以使得内部函数调用外部函数变量。

def fun1():

x=5

def fun2():

nonlocal x

x*=x

return x

return fun2()

19，递归：recursion（）

def fac(n):

    if n==1:

        return 1

    else:

        return n*fac(n-1)

number=int(input(‘请输入一个整数:‘))

result=fac(number)

print(‘%d 的阶乘是：%d‘ % (number,result))

迭代方法：

def fab(n):

    n1=1

    n2=1

    n3=1

    if n <1:

        print(‘输入有错‘)

        return -1

    while ( n-2>0 ):

        n3=n2+n1

        n1=n2

        n2=n3

        n-=1

    return n3

result=fab(20)

if result != -1:

    print(‘总共有%d对小兔子诞生：‘ % result)

递归方法：

def fab(n):

    if n < 1:

        print(‘error‘)

        return -1

    if n==1 or n==2:

        return 1

    else:

        return fab(n-1) + fab(n-2)

result=fab(20)

print(‘总共有%d对兔子诞生‘ % result)

但是递归的效率比较低

20,字典（key-value）

映射/序列

例1：

dict1={‘李宁‘:‘一切皆有可能‘,‘耐克‘:‘just do it‘,‘阿迪达斯‘:‘impossible is nothing‘}

print(‘李宁的口号是:‘,dict1[‘李宁‘])

例2:

dict3=dict(((‘f‘,70),(‘i‘,105)))

例3:

dict4=dict(小甲鱼=‘编程改变世界‘,test=‘test‘)

dict4[‘小甲鱼‘]=‘修改小甲鱼对应的value‘     -->如果没有该KEY，则会自动添加一个KEY

字典的内建方法:

0,dict2[‘key‘]-->访问字典的元素

1,fromkeys(s[,v])    -->创建或查询key

dict1.fromkeys((1,2,3))

{1: None, 2: None, 3: None}

 dict1.fromkeys((1,2,3),‘number‘)

{1: ‘number‘, 2: ‘number‘, 3: ‘number‘}

2,

keys()-->dict.keys() -->打印出dict的所有key

values()-->dict.values() -->打印出dict的所有value

items()-->dict.items() -->打印出dict所有(key,value)

get()--> dict.get(key) -->打印key对应的value

dict.get(key,‘text‘)-->打印key对应的value，如果不存在，则打印text

in操作符 --> key in dict2

clear() -->dict.clear() -->清空dict的数据

copy() -->b=a.copy()    -->拷贝字典

id(a)-->查看id

pop(key) --> dict.pop(key) -->弹出key

popitem() -->dict.popitem()  -->随机弹出key

setdefault() -->dict.setdefault(key)  -->新建key

update()   -->dict.update(dict)   -->更新字典

21，集合   --->唯一性

num={1,2,3,4,5}

set()-->set1=set(列表/元组/字符串)

不支持索引

访问集合中的值:

使用for循环一一查找

使用IN 或者 NOT IN

add()-->set1.add(value)

remove()-->set1.remove(value)

不可变集合:

num3=frozenset(元组/列表)

22,文件

输入-->处理-->输出

内存--->磁盘

open()打开文件:

open(‘filename/path‘,mode=‘rwxabt+U‘)

文件对象方法:

f.close() -->关闭文件

f.read(size=-1)  -->从文件读取size个字符

f.readline() -->以写入模式打开，如果文件存在，则在末尾添加

f.write(str) -->将str写入文件

f.writelines(seq)  ->向文件写入seq序列。seq应该是一个返回字符串序列

f.tell() -->返回当前的位置。书签

f.seek(offset,from)  -->在文件中移动文件指针，从from偏移offset字节

for each in f:    ---->浏览整个文件

print(each)

23，文件系统

模块：打包的文件系统

os模块：

常用方法：

os.getcwd():返回工作目录

os.chdir(path):改变工作目录

os.listdir(path=‘‘):列出文件目录

os.mkdir(path):创建目录

os.makedirs(path):创建递归目录

os.remove(path):删除文件

os.removedirs(path):递归删除

os.rename(old,new):文件重命名

os.system(command):运行系统的shell命令

os.curdir:指代当前目录.等价于‘。’

os.pardir:指代上一级目录

os.sep:输出操作系统的路径分隔符

os.linesep:当前平台使用的行终止符

os.name:指出当前使用的操作系统

os.path模块:

basename(path):单独返回文件名

dirname(path):单独返回目录

join(path1,path2):将path1和path2合并。path1\\path2

split(path):分割文件名和路径

splitext(path):分离文件名和扩展名

getsize(file):返回指定文件的尺寸

getatime(file),getctime(file),getmtime(file).可以使用time模块中的gmtime()或者localtime()函数转换

exists(path):判断路径是否存在

isabs(path):判断路径是不是绝对路径

isdir(path):判断目录是否存在

isfile(path):判断是否为文件

islink(path):判断是否是个符号连接

samefile(path1,path2):判断path1和path2是否指向同一个文件

ismount(path):判断指定路径是否是挂载点

24，永久存储

存放：pickling

读取:unpickling

首先要导入模块pickle

import pickle

>>> my_list=[1,2,3,‘test‘,[23,43]]

>>> pickle_file=open(‘my_list.pkl‘,‘wb‘)  --》打开一个pickle文件

>>> pickle.dump(my_list,pickle_file) --》把my_list导入到pickle_file

>>>pickle_file.close()

>>> pickle_file=open(‘my_list.pkl‘,‘wb‘)

>>> my_list2=pickle.load(pickle_file)  -->把pickle_file导入到my_list2

25,异常处理

常见标准异常:

AssertionErron/AttributeError/EOFError/IndexError/KeyError

/NameError/OSError/OverflowError/SyntaxError/TypeError/ZeroDivisionError

捕获异常：

try:

检测范围

except Exception[as reason]:

出现异常后的处理代码 print(‘代码‘)

except Exception[as reason]；

出现异常后的处理代码 print(‘daimai‘+ str(reason))

except (Error1,Error2):

处理异常的代码

try:

检测范围

except  Exception[as reason]:

处理异常的代码

finally:

无论如何都会处理的代码

raise语句抛出异常

raise Exception(‘指示代码‘)

26，丰富的else语句和简洁的with语句

else配合其他语句产生更多的功能

with语句：缩小工作量:

没有使用with前:

try:

   f=open(‘data.txt‘,‘r‘)

   for each in f:

       print(each)

except OSError as reason:

    print(‘出错啦:‘+str(reason))

finally:

    f.close()

使用with后:

try:

    with open(‘data.txt‘,‘w‘) as f:

        for each in f:

            print(each)

except OSError as reason:

    print(‘出错啦:‘+str(reason))

27,图形用户界面编程:EasyGui

导入模块三种方式:

1,import   easygui

easygui.msgbox(‘test‘)

2,from easygui import *

msgbox(‘test‘)

3,import easygui as g

g.msgbox(‘test‘)

建议不要再IDLE上运行EASYGUI

28，类和对象

关键词class

class Turtle:

#属性

color=‘green‘

weight=10

#方法:

def climb(self)

print(‘climb tree‘)

调用:

tt=Turtle() -->创建对象

tt.climb() -->调用方法

oo=面向对象

oo的特征：

1，封装

2，继承

class mylist(list):

pass --->表示只继承父类，不做其他任何改动

list2=mylist()

3，多态

self-->相当于c++的this指针

>>> class ball:

def setname(self,name):

self.name=name

def kick(self):

print(‘i am %s,who kicked me????‘ % self.name)

a=ball()

a.setname(‘test‘)

4，_init_(self) --->构造方法

>>> class ball:

def __init__(self,name):

self.name=name

def kick(self):

print(‘i am %s,who kicked me????‘ % self.name)

b=ball(‘test‘)

5,公有和私有

类属性和方法默认都是公有的

name mangling --->名字改编，名字重整

私有变量:在变量名或函数名前加上‘__‘双下划线          

访问私有变量方法:

1,在类内定义方法，间接访问私有变量

2,._类名__变量名

6，继承

class derivedclassname(basename):

....

如果子类中出现和父类相同的方法，则覆盖掉父类的方法

不想覆盖掉父类的方法：

1，调用未绑定的父类方法

 def __init__(self):

        fish.__init__(self)   ----》先调用父类同名的方法

        self.hungry=True

2，使用super函数

 def __init__(self):

        super().__init__()

        self.hungry=True

7，多重继承

class derivedclass(base1,base2,base3):

......

8，拾遗 

Mix-in编程机制

类，类对象，实例对象,实例属性（static）

如果属性的名字和方法的名字相同，则属性会覆盖掉方法

绑定:

class bb:

def printbb():

print(‘no zuo no die‘)

b1=bb()

b1.printbb() ---->会出错误

9，一些相关的BIF：

issubclass(class,classinfo)

1,一个类被认为是自己的子类

2，classinfo可以是类对象组成的元祖，只要class与其中任何一个候选类的子类，则返回TRUE

isinstance(object,classinfo)

检查对象是否属于classinfo类

1，如果第一个参数不是对象，则永远返回fasle

2，如果第二个不是类，则会抛出typeerror的异常

hasattr(object,name)  -->测定object中是否有’name‘属性

hasattr(c1,‘x‘)

getattr(object,name[,default])  -->如果有属性返回1，否则返回default

setattr(object,name,value)  -->给object中的name属性赋值vlalue

delattr(object,name)  -->删除object中的name属性

property(fget=none,fset=none,fdel=none,doc=none)设置属性，设置定义好的属性

获取属性的方法，设置属性的方法，删除属性的方法

class c:

def __init__(self,size=10):

self.size=size

def getsize(self):

return self.size

def setsize(self,value):

self.size=value

def delsize(self):

del self.size

x=property(getsize,setsize,delsize)

c1=c()

c1.x       /    c1.x=19     /c1.size

29，魔法方法（构造和析构）

特点：

1，魔法方法总是被双下划线包围，例如__init__

2，魔法方法是面向对象python的一切

3，魔法方法的魔力体现在他们总能够在适当的时候被自动调用

构造方法：

__init__(self[,...])  -->返回值一定是NONE

用在实例初始化

__new__(cls[,...])    --->第一个初始化的方法

当继承一个不可修改属性的类时，则调用此方法修改属性

class capstr(str):

def __new__(cls,string):

string=string.upper()

return str.__new__(cls,string)

析构方法：

__del__(self)   当数据不适用时，调用此方法

只有在调用了该对象的所有实例都消失时才会产生此方法

30，魔法方法：算术运算

__add__(self,other):定义加法的行为‘+‘

例子：

>>> class new_int(int):

def __add__(self,other):

return int.__sub__(self,other)

def __sub__(self,other):

return int.__add__(self,other)

>>> a=new_int(3)

>>> b=new_int(8)

>>> a+b   ---->此时a是self，b是other

-5

__sub__(sub,other):减法

__mul__(sub,other):乘法

truediv/floordiv/mod/divmod/pow/lshift/rshift/and/xor/or

divmod(a,b)返回的值是一个元祖：(a//b,a%b)

31，网络socket

socket提供较为底层的网络连接及数据传输功能

tcp socket/udp socket/unix socket

整个通信过程三步走：

客户端连接服务器：

导入模块：

import socket

创建tcp类型的socket:

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

建立到指定ip地址、端口的tcp连接

c.connect((‘211.121.12.43‘,80))

在系统上使用netstat命令查看新建的连接:

关闭连接：

c.close()

服务器端监听：

import socket

s=socket.socket(socket.AF_INET,socket.sock.SOCK_STREAM)

s.bind((‘127.0.0.1‘,80))

s.listen(1)

while True:

cs,ca=s.accept()  -->创建socket和客户端通信

cs.sendall(‘replay‘)

cs.close()

客户端收发数据:

import socket

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

c.connect((‘211.121.12.43‘,80))

向服务端发送‘hello’

c.send(‘hello‘)

读取服务端回复数据:

c.recv(1024)

c.close()

32，HTTP库实现HTTP协议

导入httplib模块：

import httplib

创建http实例，指定连接主机名和端口：

http=httplib.HTTPConnection(‘itercast.com‘,80)

指定要获取的URI:

http.request(‘GET‘,‘/ask‘)  -->get方法获取指定数据，ask表示要访问的页面

输出返回的网页body内容：

print http.getresponse().read()

关闭连接：

http.close()

更简单的urllib库：

导入urllib模块

import urllib

创建一个opener的实例

opener=urllib.build_opener()

打开指定的url

f=opener.open(‘http://www.baidu.com/ask‘)

读取返回内容

f.read()

33，python连接mysql的模块

import MySQLdb

conn=MySQLdb.connect(user=‘root‘,passwd=‘‘,host=‘127.0.0.1‘) --->连接mysql，默认是localhost

创建游标，通过游标发送sql指令

cur=conn.cursor()

conn.select_db(‘database-name‘)  --》连接数据库,本例用week

cur.execute(‘insert into userinfo(name,age) value(‘milo‘,20)‘) --》执行sql语句。insert

简单化操作方式:

sqli=‘insert into userinfo(name,age,gender) value(%s,%s,%s)‘

cur.execute(sqli,(‘a‘,37,‘male‘))

cur.executemany(sqli,[(‘test‘,34,‘male‘),(‘test2‘,36,‘female‘)])

cur.execute(‘delete from userinfo where id=20‘) -->删除数据

cur.execute(‘select * from userinfo‘) -->查询数据，但是不能直接显示，使用以下方法可以查看

cur.fetchone()-->在python上显示一行数据

cur.scroll(0,‘absolute‘)-->移动指标,此为绝对方式

cur.fetchmany(15)-->在python上显示15条数据.需要输入数据。必须先查询

cur.fetchmany(cur.execute(‘select * from userinfo‘)) -->通过一条命令显示数据

cur.close() -->关闭游标的连接

conn.close()   --->关闭数据库连接

本文出自 “ciscle” 博客，请务必保留此出处http://ciscle.blog.51cto.com/6219171/1583406

python基础笔记完整版