python3基础

本文出处  http://www.cnblogs.com/vamei    作者：Vamei

# 输出变量

a=5
print('Hello World!',a)

 # 查询变量的类型

type(a)

# sequence 序列

sequence(序列)是一组有顺序的对象的集合
序列有两种：tuple（定值表；元组） 和 list (表)
s1 = (2, 1.3, 'str', True) # s1 是一个 tuple
s2 = [True, 6, 'string'] # s2 是一个 list

tuple 和 list 的主要区别在于，一旦建立，tuple 的各个元素不可再变更，而 list 的各个元素可以再变更。
s1=[]

# tuple 和 list 的引用方式

s1 = (2, 1.3, 'str', True)
s2 = [True, 6, 'string']  
1 下标引用 s1[0] s2[2]
2 下标范围引用 [下限:上限:步长] ，上限本身不包括在内

 #常用list方法 

nl = [1,2,5,3,5]
print(nl.count(5))  # 计数，看总共有多少个5
print(nl.index(3))       # 查询 nl 的第一个3的下标
nl.append(6)            # 在 nl 的最后增添一个新元素6
nl.sort()               # 对nl的元素排序
print(nl.pop())          # 从nl中去除最后一个元素，并将该元素返回
nl.remove(2)            # 从nl中去除第一个2
nl.insert(0,9)          # 在下标为0的位置插入9

  # 词典 (dictionary)  词典的每个元素是键值对。元素没有顺序。

dic = {'tom':11, 'sam':57,'lily':100}
print(dic['tom'])
dic['tom'9] = 30
dic = {}
dic['lilei'] = 99

for key in dic:
    print(dic[key])

 # 词典 (dictionary) 的常用方法

print(dic.keys())           # 返回dic所有的键
print(dic.values())         # 返回dic所有的值
print(dic.items())          # 返回dic所有的元素（键值对）
dic.clear()                # 清空dic，dict变为{}
del dic['tom']             # 删除 dic 的‘tom’元素
print(len(dic))           #查询词典中的元素总数

# 字符串是一种特殊的元组 

str = 'abcdef'
str[2:4]

# for 循环

for a in [3,4.4,'life']:
     print(a)

# 其它循环方式

#range()
S = 'abcdefghijk'
for i in range(0,len(S),2):
    print(S[i])

#enumerate()
S = 'abcdefghijk'
for (index,char) in enumerate(S):
    print(index,char)
#zip()
ta = [1,2,3]
tb = [9,8,7]
tc = ['a','b','c']
for (a,b,c) in zip(ta,tb,tc):
    print(a,b,c)

ta = [1,2,3]
tb = [9,8,7]

# cluster
zipped = zip(ta,tb)
print(zipped)

# decompose
na, nb = zip(*zipped)
print(na, nb)

 #生成器

生成器(generator)的主要目的是构成一个用户自定义的循环对象。

生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。

# 生成器
def gen():
    a = 100
    yield a
    a = a*8
    yield a
    yield 1000

#该生成器共有三个yield， 如果用作循环器时，会进行三次循环。
for i in gen():
    print(i)

#生成器表达式(Generator Expression)
def gen():
    for i in range(4):
        yield i

G = (x for x in range(4))

#表推导   表推导(list comprehension)是快速生成表的方法。

L = []
for x in range(10):
    L.append(x**2)

L = [x**2 for x in range(10)]

  # 文件对象

f = open("test.txt","r")
#读取：
content = f.read(N)          # 读取N bytes的数据
content = f.readline()       # 读取一行
content = f.readlines()      # 读取所有行，储存在列表中，每个元素是一行。
#写入：
f.write('I like apple')      # 将'I like apple'写入文件
#关闭文件：
f.close()

# 模块   在Python中，一个.py文件就构成一个模块。通过模块，你可以调用其它文件中的程序。

#first.py
def laugh():
    print('HaHaHaHa')

#second.py
import first
for i in range(10):
    first.laugh()

#其它的引入方式
import a as b             # 引入模块a，并将模块a重命名为b
from a import function1   # 从模块a中引入function1对象。调用a中对象时，我们不用再说明模块，即直接使用function1，而不是a.function1。
from a import *           # 从模块a中引入所有对象。调用a中对象时，我们不用再说明模块，即直接使用对象，而不是a.对象。

 #模块包  可以将功能相似的模块放在同一个文件夹中，构成一个模块包

import this_dir.module

引入this_dir文件夹中的module模块。

该文件夹中必须包含一个__init__.py的文件，提醒Python，该文件夹为一个模块包。__init__.py可以是一个空文件。

# 函数的定义

def square_sum(a,b):
    c = a**2 + b**2
    return c  
    #return a,b,c  # 相当于 return (a,b,c)

#函数的参数对应

#位置传递
def f(a,b,c):
    return a+b+c
print(f(1,2,3))

#关键字传递   可以和位置传递混用。但位置参数要出现在关键字参数之前
print(f(c=3,b=2,a=1))
print(f(1,c=3,b=2))
 
#参数默认值
def f(a,b,c=10):
    return a+b+c
print(f(3,2))
print(f(3,2,1))

#包裹传递  在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。
def func(*name):
    print type(name)
    print name
func(1,4,6)
func(5,6,7,1,2,3)

def func(**dict):
    print type(dict)
    print dict
func(a=1,b=9)
func(m=2,n=1,c=11)

#解包裹
def func(a,b,c):
    print(a,b,c)
args = (1,3,4)
func(*args)
dict = {'a':1,'b':2,'c':3}
func(**dict)

#混合
在定义或者调用参数时，参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是，先位置，再关键字，再包裹位置，再包裹关键字

 #lambda函数

func = lambda x,y: x + y
print(func(3,4))

#函数作为参数传递

def test(f, a, b):
    print 'test'
    print f(a, b)

test(func, 3, 5)
test((lambda x,y: x**2 + y), 6, 9)

 #部分内置函数用法

#数学运算
abs(-5)                          # 取绝对值，也就是5
round(2.6)                       # 四舍五入取整，也就是3.0
pow(2, 3)                        # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5
cmp(2.3, 3.2)                    # 比较两个数的大小
divmod(9,2)                      # 返回除法结果和余数
max([1,5,2,9])                   # 求最大值
min([9,2,-4,2])                  # 求最小值
sum([2,-1,9,12])                 # 求和

#类型转换
int("5")                         # 转换为整数 integer
float(2)                         # 转换为浮点数 float
long("23")                       # 转换为长整数 long integer
str(2.3)                         # 转换为字符串 string
complex(3, 9)                    # 返回复数 3 + 9i
ord("A")                         # "A"字符对应的数值
chr(65)                          # 数值65对应的字符
unichr(65)                       # 数值65对应的unicode字符
bool(0)                          # 转换为相应的真假值，在Python中，0相当于False。在Python中，下列对象都相当于False： [], (), {}, 0, None, 0.0, ''
bin(56)                          # 返回一个字符串，表示56的二进制数
hex(56)                          # 返回一个字符串，表示56的十六进制数
oct(56)                          # 返回一个字符串，表示56的八进制数
list((1,2,3))                    # 转换为表 list
tuple([2,3,4])                   # 转换为定值表 tuple
slice(5,2,-1)                    # 构建下标对象 slice
dict(a=1,b="hello",c=[1,2,3])    # 构建词典 dictionary

#序列操作
all([True, 1, "hello!"])         # 是否所有的元素都相当于True值
any(["", 0, False, [], None])    # 是否有任意一个元素相当于True值
sorted([1,5,3])                  # 返回正序的序列，也就是[1,3,5]
reversed([1,5,3])                # 返回反序的序列，也就是[3,5,1]

#类，对象，属性
# define class
class Me(object):
    def test(self):
        print "Hello!"
def new_test():
    print "New Hello!"
me = Me()

hasattr(me, "test")               # 检查me对象是否有test属性
getattr(me, "test")               # 返回test属性
setattr(me, "test", new_test)     # 将test属性设置为new_test
delattr(me, "test")               # 删除test属性
isinstance(me, Me)                # me对象是否为Me类生成的对象 (一个instance)
issubclass(Me, object)            # Me类是否为object类的子类

#编译，执行
repr(me)                          # 返回对象的字符串表达
compile("print('Hello')",'test.py','exec')       # 编译字符串成为code对象
eval("1 + 1")                     # 解释字符串表达式。参数也可以是compile()返回的code对象
exec("print('Hello')")            # 解释并执行字符串，print('Hello')。参数也可以是compile()返回的code对象

#其他
input("Please input:")            # 等待输入
globals()                         # 返回全局命名空间，比如全局变量名，全局函数名
locals()                          # 返回局部命名空间

#iter()函数 可以将表、字典等容器变为循环器
for i in iter([2, 4, 5, 6]):
    print(i)

#map()函数
re =list(map((lambda x: x+3),[1,3,5,6]))
re =list(map((lambda x,y: x+y),[1,2,3],[6,7,9]))

#filter()函数  如果函数对象返回的是True，则该次的元素被储存于返回的表中。filter通过读入的函数来筛选数据。
def func(a):
    if a > 100:
        return True
    else:
        return False
re=list(filter(func,[10,56,101,500]))

#reduce()函数 依次调用lambda函数，每次lambda函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。
re = reduce((lambda x,y: x+y),[1,2,5,7,9])
上面例子，相当于(((1+2)+5)+7)+9

 

 #异常处理

try:
    ...
except exception1:
    ...
except exception2:    ...except:
    ...
else:
    ...
finally:
    ...

流程如下:

try->异常->except->finally

try->无异常->else->finally

# 动态类型

引用和对象分离，是动态类型的核心。引用可以随时指向一个新的对象

# 类定义

class Bird(object):  
    have_feather = True   
    way_of_reproduction = 'egg'
   
     def move(self, dx, dy):
        position = [0,0]
        position[0] = position[0] + dx
        position[1] = position[1] + dy
        return position

summer = Bird()
print('after move:',summer.move(5,8))                

# 类继承

class Chicken(Bird):
    way_of_move = 'walk'
    possible_in_KFC = True

class Oriole(Bird):
    way_of_move = 'fly'
    possible_in_KFC = False

summer = Chicken()
print(summer.have_feather)
print(summer.move(5,8))

 # 调用类的其它信息

class Human(object):
    laugh = 'hahahaha'

    def show_laugh(self):
        print self.laugh
    def laugh_100th(self):
        for i in range(100):
            self.show_laugh()

li_lei = Human()  
li_lei.laugh_100th()             

 # __init__()方法    创建对象时，Python会自动调用这个方法。这个过程也叫初始化

class happyBird(Bird):
    def __init__(self,more_words):
        print 'We are happy birds.',more_words

summer = happyBird('Happy,Happy!')

 # 内置函数，dir()和help()

print(dir(list))
print(help(list))

 dir()用来查询一个类或者对象所有属性

 help()用来查询说明文档