快速入门python

数据类型：

不可变数据类型（4 个）：Number（数字）、Boolean（布尔）、String（字符串）、Tuple（元组）；
可变数据类型（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

类型转换：

int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串 

数学函数：

[abs(x)]    返回数字的绝对值，如abs(-10) 返回 10
[ceil(x)]    返回数字的上入整数，如math.ceil(4.1) 返回 5
[cmp(x, y)]    如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
[exp(x)]    返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
[fabs(x)]    返回数字的绝对值，如math.fabs(-10) 返回10.0
[floor(x)]    返回数字的下舍整数，如math.floor(4.9)返回 4
[log(x)]    如math.log(math.e)返回1.0,math.log(100,10)返回2.0
[log10(x)]    返回以10为基数的x的对数，如math.log10(100)返回 2.0
[max(x1, x2,…)]    返回给定参数的最大值，参数可以为序列。
[min(x1, x2,…)]    返回给定参数的最小值，参数可以为序列。
[modf(x)]    返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
[pow(x, y)]    x**y 运算后的值。
[round(x [,n])]    返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
[sqrt(x)](    返回数字x的平方根

字符串：

字符串的格式化：

+    字符串连接    a + b 输出结果： HelloPython
*    重复输出字符串    a*2 输出结果：HelloHello
[]    通过索引获取字符串中字符    a[1] 输出结果 e
[ : ]    截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。  
in    成员运算符 - 如果字符串中包含给定的字符返回 True  
not in   
r/R    原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。

print("今天学的是%s第%d天!" % ('Python', 6))

str1 = 'Is Python' 
print ("输出Python: ", str1[2:9])

列表：

List = ['spring', 'summer', 'fall']
List.append('winter')
print ("更新后的列表 : ", List)
del List[2]
print ("更新后的列表 ："，List)

元组与列表类似，不同之处在于元组的元素不能修改。

元组：

tup1 = (1, 2)
tup2 = ('a', 'b') 
# 元组元素是不可修改的，可以进行连接。
tup3 = tup1 + tup2 
print (tup3)
#可以进行迭代
for x in (1, 2, 3): print (x, end=" ")
print(len((1, 2, 3)))#进行元素个数

字典：

字典的每个键（唯一）值 key=>value 对用冒号 : 分割，每个对之间用逗号( , )分割，整个字典包括在花括号 {} 中 。

1	len(dict) 计算字典元素个数，即键的总数。
2	str(dict) 输出字典，可以打印的字符串表示。
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

tinydict = {'Name': 'zhangsan', 'Age': 7, 'Class': 'First'}
print(dict.get("Name",))#获取字典中值
del tinydict['Name'] # 删除键 'Name' 
tinydict.clear() # 清空字典 
del tinydict # 删除字典
Dict = {}
Dict['name'] = "小明" 

集合：

集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合

remove()函数，将元素从集合中移除，元素不存在，则会发生错误。discard()函数不会。

pop()函数，集合进行无序的排列，左面第一个元素进行删除，(随机移除函数）。
copy()                   拷贝一个集合
difference()          返回多个集合的差集
intersection()       返回集合的交集
isdisjoint()            判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()            判断指定集合是否为该方法参数集合的子集。
union()                返回两个集合的并集

#集合的定义
q = {'a', 'b', 'c', 'd', 'e'}
m=set('snuni')
print(a)
#增加元素
q.add("f")
q.update({1,2,3})
q.discard("100")

迭代器：

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器有两个基本的方法：iter() 和 next() 。

字符串，列表或元组对象都可用于创建迭代器。

# 实例 2
list=[1,2,3,4] 
it = iter(list) # 创建迭代器对象 
for x in it: 
    print (x, end="向后追加")

生成器：

Python 中，使用了 yield 的函数被称为生成器（generator）。

调用一个生成器函数，返回的是一个迭代器对象。

import time
def inf_N():
    num = 1
    while True:
        yield num
        num += 1
        
if __name__ == '__main__':
    #使用变量名inf_N_gennerate绑定这个生成器
    inf_N_gennerate = inf_N()
    while True:
        time.sleep(0.5)
        #使用next()方法取生成器里面的数据
        print(next(inf_N_gennerate))

对象：

class Employee: 
    empCount = 0 
    def __init__(self, name, salary):#类的构造函数或初始化方法
        self.name = name #self 代表类的实例
        self.salary = salary 
        Employee.empCount += 1 
    def displayCount(self):
        print("Total Employee %d" % Employee.empCount)
    def displayEmployee(self): 
        print("Name : ", self.name, ", Salary: ", self.salary

emp1 = Employee("Zara", 2000) #无new关键字，用类的名称 Employee 来实例化.

emp2 = Employee("Manni", 5000) 

emp1.displayEmployee() 
emp2.displayEmployee() 

print("Total Employee %d" % Employee.empCount)

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问。

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。

类的继承

class Parent: # 定义父类
    parentAttr = 100
    def __init__(self):
        print("调用父类构造函数")
    def parentMethod(self):
        print("调用父类方法")
  
class Child(Parent): # 定义子类
    def __init__(self):
        print("调用子类构造方法")
    def childMethod(self):
        print("调用子类方法")
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法

继承多个类：

class C(A, B):   # 继承类 A 和 B

布尔函数判断一个类是另一个类的子类issubclass(sub,sup)

垃圾回收：当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。，也可以处理循环引用，循环引用是指两个对象相互引用，但是没有其他变量引用他们。

函数：

函数定义：

def func(str):
   print(str)
   return

关于文件：

#file object = open(file_name [, access_mode][, buffering])
fo = open("foo.txt", "w")

#read()和write()方法来读取和写入文件,从一个打开的文件中读取一个字符串.
fo.write( "hello!\nworld!\n")
str = fo.read(10)
print "读取的字符串是 : ", str

# 查找当前位置
position = fo.tell()
print "当前文件位置 : ", position
 
# 把指针再次重新定位到文件开头
position = fo.seek(0, 0)
str = fo.read(10)
print "重新读取字符串 : ", str
# 关闭文件
fo.close()

t    文本模式 (默认)。
x    写模式，新建一个文件，如果该文件已存在则会报错。
b    二进制模式。
+    打开一个文件进行更新(可读可写)。
r    以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb    以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
w    打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a    打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
 

os模块：

os模块提供了帮你执行文件处理操作的方法。

os.rename( "test1.txt", "test2.txt" )

# 删除一个已经存在的文件test.txt
os.remove("test.txt")

# 创建目录test
os.mkdir("test")

# 将当前目录改为"/etc"
os.chdir("/etc")

# 给出当前的目录
print os.getcwd()

# 删除”/etc”目录
os.rmdir( "/etc"  )

json.dumps	将 Python 对象编码成 JSON 字符串
json.loads	将已编码的 JSON 字符串解码为 Python 对象

条件语句：

num = 5 
if num == 4:
    print 'mmm' 
elif num == 2:
    print 'hhh'
elif num == 1:
    print 'kkk'
elif num < 0: 
    print 'error' 
else: 
    print 'roadman' 

循环语句：

while

count = 0 
while count < 5:
    print(count, " is less than 5") 
    count = count + 1 
else:
    print(count, " is not less than 5")

for

for num in range(10,20): # 迭代 10 到 20 之间的数字 
    for i in range(2,num): # 根据因子迭代 
        if num%i == 0: # 确定第一个因子 
        j=num/i # 计算第二个因子 
        print('%d 等于 %d * %d' % (num,i,j)) 
        break # 跳出当前循环
    else: # 循环的 else 部分 
        print('%d 是一个质数' % num)

break语句用来终止循环语句,continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

Python pass 是空语句，是为了保持程序结构的完整性。

使用del语句删除单个或多个对象,del var1,var2

未完待续：