+++

python2中文

#coding=utf-8
#-*- coding:utf8 -*-

类型

使用type返回实例所属的类型

>>>type(123)
int
>>>type(1.2)
float
>>>type(“hello”)
str

每个对象都有唯一的id
使用id()查看
判断实例是否属于特定类型
>>>isinstance(1,int) # Ture

>>> type(int)
<class 'type'>

赋值

>>> x=100
>>> x
100
>>> x += 2
>>> x
102

保留字

'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'

表示假的东西

False
""
None
0
[]
{}

基本类型

#!/usr/bin/python3
 
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "胖猫"     # 字符串
 
print (counter)
print (miles)
print (name)

多变量赋值

a = b = c = 1
a, b, c = 1, 2, "helloworld"

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

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

进制

0b110011 # bin 51
0o12  #oct 10
0x64  #hex 100

bin(100) #'0b1100100'
#同理 oct(100) hex(100) int()还原

#也可以指定
int("0b1100100",2)

#python3
>>>4/2
2.0
>>>3//2
1
>>> 1.0//2.0
0.0
>>> -5/2
-2.5
>>> -5//2
-3

深拷贝浅拷贝

import copy

x2 = copy.copy(x) #浅

x3 = copy.deepcopy(x) #深

浮点数

>>> 1/3
0.3333333333333333 

#转换
>>> float(100)
100.0
>>> float("-100.123")
-100.123

>>> int(2.6),int(-2.6)# 截掉小数部分
(2, -2) 

#使用math库对浮点数进行处理、
>>> from math import trunc,floor,ceil
>>> trunc(2.6), trunc(-2.6)#截掉小数部分
(2, -2)
>>> floor(2.6),floor(-2.6)#往数字小的方向取整数
(2, -3)
>>> ceil(2.6),ceil(-2.6)#往数字大的方向取整数
(3, -2)

四舍五入

>>> round(0.5)
0
>>> round(1.5)
2
#python对四舍五入操作存在不确定性 不同版本存在差异
>>> round(0.500001)
1

---

表达式

切片

>>> x = [0,1,2,3,4,5,6]
>>> s = x[2:5]
>>> s
[2, 3, 4]

x[开始：结束：步长]  
x[:5]省略开始
x[2:]省略结束
x[:]完整复制

• 索引0表示正向第一个元素 -1表示反向第一个元素

x[::-1]反向步进 全部复制
x[5:2:-1] //5 4 3 反向
x[-2:-5:-1]// 负索引 5 4 3
x[-5:-2] //2 3 4

删除

del x[3:7]

赋值

>>> x = [0,1,2,3,4,5,6]
>>> x[2:5] =[100,200] #相当于先删除 再插入
>>> x
[0, 1, 100, 200, 5, 6]

控制流

if语句

与其他语言if语句无太大差别,注意缩进就行了

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

推导式

[输出表达式 + 数据迭代源 + 过滤表达式（可选）]
[x+10 for x in range(10) if x%2==0]
[10, 12, 14, 16, 18]

while

while 判断条件：
    语句

while例子

#!/usr/bin/env python3
 
n = 100
 
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))

while。。。else。。。

#!/usr/bin/python3
 
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

break语句会导致else语句不被执行，有break但是未被执行也算else

---

运算符

> <  = !=
and or not

字符串

字符串存储Unicode文本

>>> s = "汉字"
>>> len(s)  #python的len是真实个数
2
>>> hex(ord("汉"))
'0x6c49'
>>> chr(0x6c49)
'汉'

输入(input)

在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。

>>> a = input()
123
>>> a
'123'
#如果需要整数123 则需要转换
>>> a = int(a)
>>> a
123

字符串操作

# .find()
# 查找到返回下标，查不到返回-1 ，rfind 从后面找

# .index()
# 查找不到程序错误

# .count()
# 查找次数

str.replace(str1,str2, start=0,end=len(mystr))
#遇到一个替换一个， 并不更改原串
#第三个参数 替换次数

str.split(" ")
# 字符串切割  变成列表
# split() 没有参数 默认按空格\t切

# .startswith()
# .endswith()
# 返回True

# .lower()
# .upper()
# 大写转为小写 小写转为大写

# .center(50) 居中
# ljust 靠左 rjust 靠右

# lstrip 左边空格删掉
# rstrip 右边的空格删掉
# strip 前后的空格都删掉

# .parttion("aa")
# 用aa字符串把整个字符串分成三个元组
# rparttion 从右边开始找

# splitlines
# 按行切割 删除空行

# isalpha 
# isdigit
# isalnum() 既有数字又有字母

a = ["aaa","bbb","ccc"]
b = "="
b.join(a)
# "aaa=bbb=ccc"

注释

# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""

列表（list）

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

#!/usr/bin/python3
 
# 列表的定义
list = [1, 2, 3.14 ,"老王" ]; #可以同时存储多种数据类型
list = [] # 就是列表
 
print ("list[0]: ", list[0])
print ("list[1:5]: ", list[1:5])


# 增
list.append()
list.insert(位置,添加的内容)
# list1+list2
list.extend(另一个列表) # 合并

## append和extend
#  extend只能放可以迭代的，一个一个加进去
#  append是把括号里当成一个整体 添加一个元素

# 删
list.pop() # 删除最后一个
list.remove("老王")  # 按内容删，从左边删1个
del list[2] # 根据下标删  删除第三个元素

# 改
list[下标] = 新值

# 查
# in  /  not in
if "老赵" in names:
    print("找到了")

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

字典 （dictionary）

须是唯一的，但值则不必
可变类型不能当key（列表和字典）

#!/usr/bin/python3
infor = {键:值,键:值}
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

#修改
dict['Age'] = 8;               # 更新 Age（key存在）
dict['tangyuan'] = "汤圆"      # 添加信息(写一个新的key)

#查
dict['tangyuan']  #查找  key不存在报错
dict.get("tangyuan")  # key不存在不报错

#删除
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

# 所有的键
infor.keys() # python2是列表 python3是对象
infor.values()
infor.items() # 列表 [两个元组]  每次循环都有key和value

元组（tuple）

注：元组只能读 不能修改

tup1 = ('Google', '汤圆', 1997, 2000)#定义元组
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])#访问元组
print ("tup2[1:5]: ", tup2[1:5])

a = (11,22)
b,c = a # b = 11   c = 22  (拆包)


tup1 = ();#创建空元组

#元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

集合（set）

存储非重复元素 , 集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
 
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

for

for <variable> in <sequence>:
    <statements>
else:
    <statements>

languages = ["C", "C++", "Perl", "Python"] 
for x in languages:
    print (x)

#range
>>>for i in range(5):
...     print(i)

for循环的else

nums = [11,22,33,44]

for tmp in nums:
    print(tmp)
else:
    print("===") # 循环正常结束打印一次（一定会执行）
    #在for循环里break  不会进入else

4.函数

#函数创建
def test(x, y=10):
    x+=100
    print(x,y)
test(1,2) #输出101 2
test(20) #输出 120 10

匿名

add = lambda x,y : x + y

print(add(1,2))  #3

参数

def test(a,b,c=33,d=44,*args):#*args是位置参数收集
    print(locals())

test(1,2,3,4,5,6,7,8)
#输出结果 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'args': (5, 6, 7, 8)}

返回值

def test(n):
    if n>0:
        return 1,2,3 #返回多个数
    elif n<0:
        return -1,-2
    return 0

print(test(1))  #(1, 2, 3)
print(test(-1))  #(-1, -2)
print(test(0))  #0

全局变量

放在函数调用之前

wendu = 0

def fun():
    global wendu  # 声明修改全局变量
    wendu = 33 

匿名函数

# 对列表里的字典排序
infor.sort(key=lambda x:x['name'])

#参数传递
def test(a,b,func):
    result = func(a,b)
    return result

num = test(11,22,lambda x,y:x+y)
print(num)

+=

python都是引用

如果是可变类型 直接修改，如果是不可变 ，指向一个新的
num += num #直接修改num的值
num = num + num #先得到一个临时的值，再重新指向

文件

大象怎么关进冰箱

读写文本文件

# fileRW.py

# 将一个列表中的字符串写入文件
f = open('test1.txt','w')
for x in ['aaa',123,'汤圆',True,'tangyuan']:
    if type(x) == str:
        f.write(x)
f.close()

#一次性读出到字符串
f = open('test1.txt','r')
xx = f.read()
print('xx=',xx)
f.close() 

f.read(1) #读取一个字节

f.readline()  # 返回值是字符串
f.readlines() # 返回值是列表  每一行是一个元素

#输出结果：xx= aaa汤圆tangyuan

打开模式

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

---

模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

文件定位

.seek(2,0) # 从开头 向后偏移2个字节

f.seek(0,0) # 回到开头
f.tell()# 当前位置

# 第一个参数
微调 #python3不支持负数

# 第二个参数
0 文件开头
1 当前位置
3 文件末尾

文件重命名 删除

os.rename
os.remove
os.mkdir
os.chdir #改变默认路径
os.getcwd
os.listdir("./") # 当前路径下所有文件

---

迭代器

#手工迭代
>>> d = [0,1,2]
>>> x = d.__iter__()
>>> x.__next__()
0
>>> x.__next__()
1
>>> x.__next__()
2
>>> x.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

#自动迭代
for i in [0,1,2]:
    print(i)#输出 0 1 2

---

面向对象

图纸（类） 飞机（对象）

• 类的名称：类名
• 类的属性：一组数据
• 类的方法：允许操作的方法（行为）

类

class A:
    a = 100

    def __init__(self,x): # 定义方法必须写上self
        self.__x = x;  #self相当于其他语言的this

    def __str__(self): # 可以直接print
        return "__x=%d" % __x

    #私有方法
    def __send_msg():
        pass

    def get_x(self):
        return self.__x

class B(A):
    b = "hello"
    def __init__(self,x,y):
        super().__init__(x)
        self.y=y

    def get_y(self):
        return self.y

o = B(1,2)

print(o.get_x(),o.get_y())## 1 2

私有字段(Attribute)用双下划线开头__name
保护字段 protected _name 只循序本身和子类访问

继承

class A(object)     :pass
class B(A)  :pass
class C(B)  :pass

issubclass(A,object) #true
type(A) is A.__class__ #true

B.__base__ #A
A.__subclasses__() #[B]

初始化

__init__是可选的

覆盖(override)

class A(object):
    def m(self):print("A.m")
    def do(self):self.m()

class B(A):
    def m(self):print("B.m")

A().do()  #输出 A.m
B().do()  #输出 B.m

类的专有方法

• init : 构造函数，在生成对象时调用
• del : 析构函数，释放对象时使用
• str: 转文本 str(obj)
• repr : 打印，转换
• setitem : 按照索引赋值
• getitem: 按照索引获取值
• len: 获得长度
• cmp: 比较运算
• call: 函数调用
• add: 加运算
• sub: 减运算
• mul: 乘运算
• truediv: 除运算
• mod: 求余运算
• pow: 乘方

实例方法、类方法、静态方法

操作类 用类方法
操作实例 用实例方法
做一些和类数据没有关系的操作 用静态方法

class Game(object):
    #类属性
    num = 0 

    #实例方法
    def __init__(self):
        #实例属性
        self.name = "laowang"
    
    #类方法
    @classmethod
    def add_num(cls): # cls保存类的引用
        cls.num=100 #类方法为了修改类属性

    #静态方法
    @staticmethod
    def print_menu():
        print("-------------")

#调用类方法
Game.add_num() #可以通过类名调用
game = Game()
game.add_num() #也可以通过对象调用

#调用静态方法
Game.print_menu() #ok
game.print_menu() #ok

new方法

class Dog(object):
    def __init__(self):
        pass

    def __del__(self):
        pass

    def __new__(cls):
        return object.__new__(cls) # 返回值是对象的一个引用

dog = Dog()     # 1.调用__new__ 只负责创建对象
                # 2.调用__init__ 只符合初始化
                # 3.返回对象的引用

单例

class Dog(object):

    __instance = None

    def __new__(cls):
        if cls.__instance == None:
            __instance = object.__new(cls)
            return __instance
        else:
            return __instance

a = Dog()
print(id(a))
b = Dog()
print(id(b))

一次初始化

单例

class Dog(object):

    __instance = None
    __init_flag = False #添加一个标志位

    def __new__(cls,name):
        if cls.__instance == None:
            __instance = object.__new(cls)
            return __instance
        else:
            return __instance

    def __init__(self,name):
        if Dog.__init_flag==False:
            self.name=name
            Dog.__init_flag = True #只初始化一次

a = Dog("旺财")
print(id(a))
b = Dog("哮天犬") # 虽然是单例，但是会init两次
print(id(b))

---

异常

import sys
def test():
    try:
        raise Exception("err")
    except: #python2的捕获所有异常，python3加个Exception
        print(sys.exc_info())
        raise # 重新抛出异常，触发默认异常处理
        
test()
#(<class 'Exception'>, Exception('err'), <traceback object at 0x0000026EB3FB70C8>)

异常处理

• try 需要保护的代码块
• except 异常发生时 按所属类型捕获
• else 未发生异常执行 前面需要至少有1个except
• finally 无论是否发生异常 总是执行

def test(n):
    try:
        print("try")
        if not n:
            raise Exception()
    except (NameError,FileNotFoundError): 
        print("#python3捕获多个异常 加括号 是元组")
    except Exception as e:
        print("所有异常的总称")
        print(e)
    else:
        print("没有异常才会执行")
    finally:
        print("不管是否产生异常 总会执行")
        # 关文件

test(0)
#try
#except
#finally
test(1)
#try
#else
#finally

---

模块

pip 管理python模块的工具

import sys  #引入所有函数
from xxx import * #引入模块中所有函数
from xxx import xxx,xxx  #引入xxx函数 没列入的不引入
import xxx as xxx #重命名 

使用from example.module01 import * 调用函数不需要加包名 如myfun1(10,20) 使用from example import module01 调用函数需要加模块名和函数名，不需要加包名 如module01.myfun1(10,20)

包

创建一个__init__.py的空文件，这个文件夹就是包
导入包 这个文件就会执行

__all__ = ["send_msg"] # 影响from

#print("hahaha") #导入包会执行的

#import sendmsg # 导入包 python2用

from . import sendmsg

制作模块

在包文件夹相同路径旁边 新建一个setup.py

from distutils.core import setup

setup(name="test", version="1.0", description="xuehu96's module", author="xuehu96", py_modules=['TestMsg.sendmsg', 'TestMsg.recvmsg'])

运行安装

#编译
python3 setup.py build
python3 setup.py sdisk

#安装
tar -zxvf 压缩包
python3 setup.py install #安装到系统里

给程序传参数

import sys

print(sys.argv)

print("欢迎%s的到来"% sys.argv[0])

列表推导式

创建一个很大的列表

python2 range有风险
python3 什么时候要什么时候生成

a = [ i for i in range(1,18)] #1-17
b = [ 1111 for i in range(10)] #10个1111
c = [ i for i in range(10) if 1%2==0] #for和if
d = [ i for i in range (3) for j in range(2)] #6次 [0,0,1,1,2,2,]
e = [(i,j,k) for i in range(3) for j in range(2) for k in range(3) ] # [(000)(001)(002)(010)....(212)]