python小记

查找替换 ctrl + r
注释 ctrl+/
格式化代码 ctrl+alt+l

跳转到定义 ctrl+alt+b

 

常用数据类型
数值类型：int float是两个比较常用的数值类型。
Bool类型。
String类型。'vichin' "vichin" """vichin""" '''vichin''' 

content = """
        中国
        人民
        站起来了
        """
print(content)

List（列表）类型。
Set(集合)
Tuple(元祖)
Dictory(字典)
NoneType(空类型)

print(type(2))——————查看数据类型

数值转换成string  str(123)                        

数值转换成char    chr(1)

float('132.3')

string转int int('66')

将某个数转换成Unicode字符     unichr (x)

将x转换成对应的整数        ord(x)

将x转换成为一个16进制的字符串    hex(x)

将x转换成为一个8进制的字符串    oct(x)

计算字符串中的有效表达式，并返回对象    eval(str)

将序列s转换成一个元祖    tuple(s)

将序列s转换成一个列表    list(s)

 求2的10次方 print(2**10)_______1024
整除运算 print(5//2)______2
取模 print(5%2)_________1

与 或 非  and，or，not

print(not True)——false

在python中，非0即真，非空即真。

在python中，比较运算符与C#中的完全一样使用。


输入参数

content = input("请输入内容：")
print(type(content))
print(content)

退出程序
import sys
sys.exit()

print函数一共有5个参数：print（values,sep,end,file,flush）
values:是输出的值，可以输出多个值，如果值与值之间要做分割的话，那么就会使用第二个参数。
sep:分隔符
end:输出完毕之后，以指定的字符结束。
file:默认是输出到控制台，也可以写入到文件句柄。

打印多个值
print(44,22)——默认是以空格进行分割

name = 'vichin'
age = '26'
print('我是{0},今年{1}岁', format(name, age))

print('abc',end='*') 输出abc,以*号结尾

当end=""的时候，表示输出不自动换行。


指定输出数据的分隔符
print('a','b','c',sep=',') 输出a,b,c

python中没有do while 循环，有while循环

在python中使用for循环（感觉像foreach）,跳出循环仍然是break，结束本次循环仍然是continue

pets = ['james', 'curry', 'love', 'wade']
for x in pets:
    print(x)

 可以使用pass语句充当占位符。

 print(ord("a"))#返回ASCII码值

abs(num)#>>求绝对值
min(1,12,5)  #>>求最小值
round(num[,n])#>>  n表示保留多少位小数

#导入模块（模块相当于c#中的静态类，如DateTime.Now();）
import math

math.ceil(3.5) #向上取整
math.floor(5.2)#向下取整
math.sqrt(25)#结果等于5，进行根号运算
print(math.log(10000, 10))#结果为4,10的4次方为10000

#导入random模块
import random
print(random.random())

sequence = [1, 3, 5, 7, 9]
print(random.choice(sequence))  # 从一个范围中，随机取一个数出来



import math

hudu = math.radians(30)  # 先将角度转换成一个弧度
result = math.sin(hudu)  # 在求正弦
print(result)

content = 'hello' + 'world'
print(content[1])
# python中没有substring函数，可以使用[]来取得字符串中的值
print(content[0:3])  # hel
print(content[0:len(content):1])  # 从0开始，取所有字符串,1代表着步长。如果要取1,3,5,7位置上的字符，则需要把1变成2。结果为：helloworld
print(content[4:1:-1])  # 当步长变成了负整数的时候，则说明往左取值。结果为：oll
print(content[::-1])  # 反转字符串 结果为：dlrowolleh

len('abc')#获取字符串长度。
content = 'hello' + 'world'
print(content.find('e'))  # find方法，有点像js中的indexOf方法
# find方法有3个重载，第一个参数表示需要找的字符，第二个参数表示从第几个开始找，默认是0。第三个参数表示到第X个字符串结束。最后一位字符是取不到的
print(content.find('l', 5))  # 返回值是8
print(content.replace('l', '*'))  # 有3个参数，第三个参数表示要替换的个数。
content.lower()  # 字符串小写
content.upper()  # 字符串大写
content.strip()  # 相当于trim()   lstrip()   rstrip()
print(content.split('o'))  # 结果返回一个列表（数组）。结果是：['hell', 'w', 'rld']
print('o'.join(['hell', 'w', 'rld']))  # 返回  helloworld
print(content.isalpha())  # 返回 True。判断字符串中是否全都是字母
print(content.isdigit())  # 返回 False，判断字符串中是否全都是数字
print(content.isalnum())  # 返回 True，判断字符串中的字符是否都是数字和字母
print(content.isspace())  # 返回 False ，判断字符串中，所有的字符是否都是空白符，制表符，换行符
print(content.startswith('h'))  # 返回 True，相当于C# 中的startwith()。该函数有重载
print(content.endswith('.doc'))  # 返回False，判定字符串是不是以.doc结尾 （判断文件的后缀名）
print('w' in content) #返回 True,相当于contains

content.title()  # 字符串中，每个单词大写
content.ljust(13, '*')  # 如果字符串长度小于13位，按么就将字符串的长度变成13位，并且使用*号来填充多余出来的位置
print(content.partition('w'))  # 返回结果：('hello', 'w', 'orld')

num = range(1, 100, 2)  # s生成1~99之间的基数
ary = [1, 2, 3, 4, 5, 6]
ary.append(1)  # 向列表中追加元素
ary.extend(num)  # 向列表中追加一个可迭代的序列。append是加一个元素，而extend是一批元素
ary.insert(3, 'vichin')  # 向列表的指定位置插入元素

nums = [1, 2, 3, 4, 5]
del nums[1]  # 将2从列表中删除
del nums  # 将该列表删除
print(nums.pop())  # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
ary.remove(2)  # 讲列表中，元素2从列表中删除
nums[2] = 6  # 将第3个元素修改成6
nums.index(5)  # 获取元素5的索引
num.index(5, 3)  # 获取从第2个元素开始，元素5所在的位置，若有3个参数，则第三个参数表示为结束位置

a = ['a', 'b', 'v', 'v']
print(max(a))  # 范围结果是v
n = [1, 2, 3]
x = [a, n]  # 嵌套列表
print(x[0][1])  # 结果为b
print(a.count('a'))  # 计算a元素在列表中出现的次数

print(list(enumerate(a)))  # 枚举对象 ，返回值：[(0, 'a'), (1, 'b'), (2, 'v'), (3, 'v')]
for idx, val in enumerate(a):
    print(idx)
    print(val)

print('c' in a)
print('c' not in a)
print(sorted(a, reverse=True))  # 将列表降序
a.sort()  # sort方法只能用于列表，不能用于字符串，并且该方法会更改列表本身的值，并不返回对象，上面那个方法会返回一个排序后的值，但是不会改变对象本身

def GetKey(x):
    return x[1]
rst = a.sort(key=GetKey)  # GetKey后面不写小括号表明是有sort方法来调用，而写了小括号表明立即调用。reserve=True

import random
random.shuffle(a)  # 将列表a乱序排列 。返回值是none。直接改变列表本身
a.reverse()  # 翻转列表 返回值是none。直接改变列表本身
import collections

print(isinstance(a, collections.Iterable))  # 检查元素是否可遍历

# 迭代器：可以记录遍历位置的对象，送第一个元素开始，往后通过next()函数进行遍历，只能往后不能往前。
enum = iter(a);#根据列表生成一个迭代器
print(next(enum))  # 返回a  执行一次之后，就会将当前的位置加一
print(next(enum))  # 返回b
print(next(enum))  # 返回v
print(next(enum))  # 返回v

# 元祖是无法做增，删，改操作的，只能做查询操作。
t = (1, 2, 3, 4, 5, 6, 2)
print(t[1])  # 打印第二个元素
print(t.count(2))  # 打印元祖中，2的个数
print(t.index(2))  # 打印2的位置
print(max(t), min(t))
print(1 in t)
print(1 not in t)
print(('chen', 'wei') * 2)

# 快速交换两个变量的值
a = 1
b = 2
b, a = (a, b)
print(b,a)

# 字典是一个可变的集合，key必须是一个字符串、数字、元祖（都是不可变的元素），列表就不能充当key
dict = {'abc': 123, 98.6: 37}

# 向字典中添加值
dict['name'] = 'vichin'
dict['age'] = 26
print(dict)  # 打印 {'abc': 123, 98.6: 37, 'name': 'vichin', 'age': 26}
afc = ['China', 'India', 'Korea', 'Japan']
dic = dict.fromkeys(afc, '666')  # 将一个序列转化为一个字典，并且将序列里的内容变成key。列表可以替换成string
print(dic)  # 打印 {'China': '666', 'India': '666', 'Korea': '666', 'Japan': '666'}

# 修改字典中的值
dict['abc'] = 321
print(dict['abc'])  # 打印 321
dic.update({'name': 'vichin', 'age': 26})  # 将update方法中的字典追加到dic这个字典中去，如果发现有重复的key，那么就会更改那个key的值
print(dic)

# 删除字典中的元素
print(dic.pop('India'))  # 将india这一项从字典中删除，并且返回india这个key所对应的value值pop('fdas',8897)。如果字典中不存在fdas这个key的话，那么就返回8897
dic.popitem()  # 随机返回并删除字典中的一对键和值(一般删除末尾对)
del dict['abc']
del dict[98.6]
print(dict)  # 打印 {'name': 'vichin', 'age': 26}
print(len(dict))  # 计算字典中，元素的个数。
dict.clear()  # 清空字典
del dict  # 删除字典

# 获取字典中的值
dic.get('name')  # 返回key所对应的value,如果输入的key不存在，则返回一个none，或者可以自己设置一个默认值
c = dic.setdefault('sex')  # 获取key所对应的value，如果key不存在。则将其追加到字典中去
print(dic)
dic.keys()  # 获取所有的key
dic.values()  # 获取所有的value
dic.items()  # 获取所有的键值对
for key in dic.keys():
    print(key)
for k, v in dic.items():
    print(k, v)
print(len(dic))  # 打印字典长度
print('America' in dic)  # 判断字典中是否存在america这个key

# 集合：仅用于对key的存放。不存储value,由于key不能重复，所有在集合中，是没有重复项的
s = set(['name', 'age', 'sex'])

# 向集合中增加一个key
s.add('address')
print(s)

# 将指定的key从集合中删除
s.remove('address')
s.discard('age')  # 如果集合中存在改key，则删除，否则就不做操作。较remove方法来说，主要是该方法不会报错（没有Key的时候）
s.pop()  # 随机删掉一个key
print(s)

its = iter(s)  # 生成一个迭代器
# 1使用next()来访问迭代器。next()会依次访问集合中的元素。迭代器用完就会被废除
print(next(its))  # 打印1
print(next(its))  # 打印2
print(next(its))  # 打印3

itss = iter(s)

for v in itss:
    print(v)  # 依次打印出 2,3,4

# 不可变集合
sss = frozenset(1, 3, 5, 7)

# 集合可以看成数学上无序和无重复元素的一组元素。因此集合可以做数学上的交集和并集操作
s2 = set([2, 3, 4])
s1 = set([1, 2, 3])
print(s1 & s2)  # 并集操作  打印 {2, 3}
print(s1.issuperset(s2))  # 打印 false 判断s1是否是s2的超集
print(s1.isdisjoint(s2))  # 打印false  判断两个集合是否不相交
print(s1.issubset(s2))  # 打印false  判断s1是否是s2的子集合
print(s1.update(s2))  # 将S1和S2做并集操作，并且将结果放到S1这个变量中去（做了并集，并且改变了S1本身）
print(s1 | s2)  # 交集操作  打印 {1, 2, 3, 4}
print(s1 - s2)  # 差集操作 打印{1}

# python 中操作时间
import time

time.sleep(1)  # 休眠1秒
result = time.strftime('%Y-%m-%d %H:%M:%S')
print(result)

import datetime

t = datetime.datetime.now()
print(t.year)
print(t.month)
print(t.day)
print(t.hour)
print(t.minute)
print(t.second)

nextWeek = t + datetime.timedelta(days=7)
print(nextWeek)

firstDay = datetime.datetime(2018, 4, 30, 18, 39, 00)
secondDay = datetime.datetime(2018, 5, 11, 15, 00, 00)
delta = secondDay - firstDay
print(delta)  # 计算两个日期之间相差多少时间
print(delta.total_seconds())  # 计算两个日期之间相差多少秒

# python 读取UTF-8编码的文本文件
path = 'C:/Users/cim.outsource02/Desktop/项目地址.txt'
with open(path, 'r') as f:  # with 相当于C#中的using
    if f.readable():  # 文件是否可读
        f.seek(2)  # 光标向后移2位，如果seek(-3,2)从倒数第三位开始，向后读两个字符。该情况只能出现在文本模式意外的模式下
        f.tell()  # 获取当前光标位置
        print(f.read())
# read()方法会一次读取文件内所有的内容，当内容太大的时候，就不适合用该方法。可以使用readline()来读取每一行的数据。或者是使用read(150)来读取指定的150个字节的内容。


with open(path, 'r') as f:
    for line in f.readlines():
        print(line)

# 如果要读取非UTF-8编码的文本文件可以在open方法中指定编码格式。
open(path, 'r', 'gbk')
# 当读取编码不规范的文件会报错：UnicodeDecodeError（可能是碰到了非法编码的字符），可以在open方法中传入参数error，来忽略错误。
open(path, 'r', encoding='gb2312', errors='ignore')

# python读取二进制文件（图片，视频）
picPath = r"C:/Users/cim.outsource02/Desktop/无标题.png"
with open(picPath, 'rb') as k:
    print(k.read())

# python 写文件
txtPath = r'H:/临时文件.txt'
with open(txtPath, 'w') as f:
    if f.writable():
        f.write('第一次使用python向文本文件中写入字符')

with open(txtPath, 'a') as f:
    f.write('向文本中的内容，后面追加内容')


# 复制文件
srcFile = open('dd.txt', 'r', encoding='utf-8')
pseFile = open('ee.txt', 'w', encoding='utf-8')
while True:
    content = srcFile.read(1024)
    if len(content) == 0:
        break
    pseFile.write(content)
srcFile.close()
pseFile.close()

import shutil,os
#使用shutil中的copy方法复制文件。
shutil.copy("F:\PythonDemo\dataFile.txt","F:\book\dataFile.txt")

#使用shutil模块中的copytree方法对文件夹进行复制。
shutil.copytree("原有的路径","新的路径")



import os

#使用os.path中的join方法来拼接路径，得到的路径为：userinspam
myPath=os.path.join("user","bin","spam")#join后面是可变参数，可以传入多个字符串

#使用os.getcwd方法来获取当前工作目录。打印出来的结果是：F:PythonDemo
print(os.getcwd())

#使用path模块中的abspath方法获取绝对路径。打印结果：F:PythonDemo
print(os.path.abspath("."))
#使用path模块中的isabs方法判定给定的路径是否是绝对路径。打印结果：true
print(os.path.isabs(os.path.abspath(".")))

#获取相对路径的字符串。os.path.relpath有两个参数，path和start，如果start不写的话，那么就以当前工作的目录环境来作为start。
print(os.path.relpath("F:\book"))#当前工作的环境是F:\PythonDemo。 打印结果：..ook

#调用os.path模块下的dirname和basename方法来获取给定文件所在的路径和完整名称。
myAppPath="E:QQ轻聊TencentQQLiteBinQQ.exe"
print(os.path.dirname(myAppPath))#打印结果：E:QQ轻聊TencentQQLiteBin
print(os.path.basename(myAppPath))#打印结果：QQ.exe

#使用os.path模块下的sep属性结合split方法，将返回的给定文件的路径置于列表当中
print(myAppPath.split(os.path.sep))#打印结果：['E:', 'QQ轻聊', 'Tencent', 'QQLite', 'Bin', 'QQ.exe']

#使用os.path模块下的getsize方法获取给定文件的大小，单位：byte。
print(os.path.getsize(myAppPath))#打印结果是：106816

os.rename('aa.txt', 'bb.txt')
os.rename('旧的文件夹名', '新的文件夹名')

os.remove('cc.txt')  # 删除文件
os.rmdir('文件夹路径')  # 删除文件夹，该文件夹内不能有其他文件，否则无法删除
os.removedirs('work/test')  # 递归删除文件夹。会将work和test这两个文件夹都删掉
#使用shutil模块中的rmtree方法删除文件夹（包含在文件夹内的文件夹和文件都会被删除）
shutil.rmtree("path")

#使用os中的unlink删除文件
os.unlink("F:\book\dataFile.txt")

os.makedirs("F:\Vichin")  # 不能创建多个目录，只能一级一级的创建

#使用os模块中的listdir方法来获取给定路径下的文件夹和文件的名称。
os.listdir('F:\PythonDemo')#返回结果：['.idea', 'demo.py', 'learning_step_flowchart.png', 'opencvDemo.py', 'RandomColor.png', 'RandomGray.png', 'test.py']
os.listdir('./')  # 获取当前文件夹下的文件，返回的是一个列表    （../表示上一级目录）

os.path.exists('path')  # 判断该路径是否存在
os.path.isdir('path')  # 判断是否是一个文件夹
os.path.isfile('path')  # 判断是否是一个文件

#使用第三方模块send2trash，将文件放入到回收站
import send2trash
send2trash.send2trash("要删除的文件路径")

# #python程序中的seesion
# import shelve
# mySessionData=shelve.open("mySession")
# mySessionData["key"]="vichin"
# mySessionData.close()
#
# #在python中使用文件来缓存数据
# #存数据
# import pprint
# name="vichin"
# fileObj=open("myData.py","w")
# fileObj.write("name="+pprint.pformat(name)+"
")
# fileObj.close()
# #取数据
# import myData
# print(myData.name)

def SayHello():
    print('Hello Word!')


def AddNum(num1, num2):
    print(num1 + num2)


AddNum(1, 4)


def GetNum():
    return 2


AddNum(GetNum(), GetNum())

# 这里是函数的说明。这个是python中的lambda表达式
GetAddNum = lambda para1, para2: para1 + para2
print(GetAddNum(5, 6))

# 作用域：在python中，只有模块，类，函数（lambda）才会引入新的作用域，其它的代码块是不会引入新的作用域。（也就是说这些语句内定义的变量，在外部也可以访问）

total = 0  # 这是一个全局变量


# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2  # total在这里是局部变量.
    print("函数内是局部变量 : ", total)
    return total


# 调用sum函数
sum(10, 20)
print("函数外是全局变量 : ", total)


# 函数内是局部变量 :  30
# 函数外是全局变量 :  0
# 经过运算过后，total的值并没有发生变化。
# 修改 total变量（使用global和nonlocal来修改外部变量的值，global是用来修改全局变量的值，nonlocal是用来修改当前作用于外，但又不是全局作用域下的变量）
# global的使用
def sum1(para1, para2):
    global total
    total = para1 + para2
    return total


sum1(3, 4)
print(total)


# nonlocal的使用
def outer():
    num = 10

    def inner():
        nonlocal num  # nonlocal关键字声明
        num = 100
        print(num)

    inner()
    print(num)


outer()


def AddNum(num1, num2):
    return num1 + num2


AddNum(1, 2)


# 调用不定长参数
def AddNums(*args):
    """
    多个数作相加操作
    :param args: 传入不定长参数
    :return: 返回数字的和
    """
    result = 0
    for i in args:
        result += i
    return result


print(AddNums(11, 12, 13, 14, 15))


# 缺省参数
def hit(someOne='豆豆'):
    """
    打豆豆，嘿嘿！
    :param someOne:被打的人
    :return:
    """
    print(someOne)


hit()  # 打印 豆豆
hit('木耳')  # 打印 木耳

help(hit)

# 闭包
def CheckLogin(function):  # 这里的function是一个函数
    def inner(para1,para2):
        print('do sth……')
        function()
    return inner


def DoSth(para1,para2):
    print('do sth')


var = CheckLogin(DoSth)  # 如果不用闭包，而是直接将inner函数赋值给var的话，那么inner方法就会被先执行一次。使用了闭包就不会被执行了。

# 装饰器模式：在不改变原函数的函数体的前提之下，为该函数增加功能
DoSth = CheckLogin(DoSth)
# 或者在原本的函数之后，增加@函数名
@CheckLogin
def DoSth(para1,para2):
    print('do sth!')

#装饰器叠加
#@装饰器1
#@装饰器2
def DS(func):
    def sd():
        func
        print('DS')
    return sd

#有返回值的装饰器
def ds1(func):
    def inner1(para1,para2):
        print('ds……')
        result=para1+para2
        return result
    return inner1
@ds1
def AddNum(para1,para2):
    return  para1+para2

#根据不同的参数，生成不同的装饰器
def Generaters(para):
    def ds1(func):
        def inner():
            print('do sth...'+para)
            func
        return  inner
    return ds1

@Generaters('para')
def Do():
    print('do sth...')

  

#生成器。特殊的迭代器
# （1）将列表推导式的中括号改写成小括号就可以。
#（2）使用yield语句生成一个生成器
def testG():
    yield 1
    yield 2
    yield 3

temp=testG()
print(next(temp))#打印 1
print(next(temp))#打印 2
temp.close()#关闭生成器

  

# 面向对象遵循的原则：SOLID
# S(Single Responsibility Principle：单一职责原则)：一个类只负责一个职责；这样有利于写出高内聚的代码，还有利于代码的复用。
# O(Open Closed Principle：开放封闭原则)：对扩展开放，对修改关闭；易于维护，保证代码安全性以及扩展性。
# L（Liskov Substitution Principle：里氏替换原则):防止代码出现不可预知的错误；方便针对于基类的测试代码，可以复用在子类上。
# I(Interface Segregation Principle:接口分离原则)：如果一个类包含了过多的接口方法，而这些方法在使用的过程中并非‘不可分割’，那么应当把他们进行分割；这样可以提高接口的重用价值。
# D(Dependency Inversion Principle:依赖倒置原则)：高层模块不应该以来低层模块，它们应该抽象类或者接口
# 变量名称：class_ 用于区分python中的关键字class
# __init__ 在变量两遍加上2个下划线，这是系统内置的命名方式。不允许使用


class Person:
    def DoSth(self):
        print('这个是实例方法')  # selef就是该类产生的实例

    @classmethod
    def ClsFun(cls):
        print('这是一个类方法')

    @staticmethod
    def StaticFun():
        print("这是一个静态方法")


class People(object):
    def Eat(self):
        print('吃饭！')


class Student(People):
    # 用来限制该class实例能添加的属性
    __slots__ = ('price')  # 用tuple定义允许绑定的属性名称,出现在该元祖中的属性名称不能是类已有的属性

    # 定义一个构造函数
    def __init__(self, name, age, sex):
        self.__name = name  # 定义一个私有变量__name,用于接收外部传进来的name。下面的ShowName方法中，就使用self.__name
        self.__age = age  # 在python中__age是私有变量（两个下划线），这种私有变量只能在该类中被访问（子类也不能访问,通过该类生成的实例也无法访问）
        self.__sex = sex

    def __del__(self):
        print('这个对象被释放了！')  # 当对象被释放的时候，会执行的方法

    # 定义Student的方法
    def ShowName(self):
        print(self.__name)

    # 描述器：相当于public string _name{get;}
    @property
    def name(self):
        return self.__name

    # 描述器：
    @name.setter
    def name(self, value):
        self.__name = value

    # 描述器：相当于public int _age{get;}
    @property
    def age(self):
        return self.__age

    # 描述器：相当于 public int _age{set;}
    @age.setter
    def age(self, age):
        self.__age = age

    # 描述器： 相当于public string _sex{get;}
    @property
    def sex(self):
        return self.__sex

    # 描述器：
    @sex.setter
    def sex(self, value):
        self.__sex = value


xs = Student('vichin', 26, 'male')
xs.ShowName()
xs.Eat()  # 调用父类中的Eat方法
print(xs.sex)

print(dir(xs))  # 获取对象的所有属性

# 在python中，存在实例属性和类属性。类属性：顾名思义就是类本身的属性。实例属性其实就是当一个类被实例化后，该实例可以声明一个自己的属性。
# 当这个属性和类的属性相同时，代码并不报错。所有申明实例属性的时候，千万不要和类属性相同。
xs.price = 250  # 声明一个实例属性，该属性在Student类中并不存在
print(xs.price)


# python中允许多重继承，即：一个类可以继承多个类。C#是单一继承，每次只能继承一个类（能继承多个接口）。

class Animal(object):
    pass


# 大类:
class Mammal(Animal):
    def __init__(self):
        print('sayHi')
    pass


class Bird(Animal):
    pass


class Runnable(object):
    def run(self):
        print('Running...')


class Dog(Mammal, Runnable):  # 继承了两个类，不推荐这样做。
    pass


class BarkMixIn(object):
    def bake(self):
        print('喵...')


class EatFishMixIn(object):
    def eatFish(self):
        print('吃鱼...')


class Cat(Mammal, BarkMixIn, EatFishMixIn):  # 推荐做法：MixIn相当于C#中的接口。
    pass

mao=Cat()
mao.bake()
mao.eatFish()

import abc
#python中的多态:python中并没有真正意义上的多态。
class Human(object,metaclass=abc.ABCMeta):
    @abc.abstractmethod#声明SayHi为抽象方法
    def SayHi(self):
        pass

class Chinese(Human):
    def SayHi(self):
        print('你好！')

class American(Human):
    def SayHi(self):
        print('Hello!')

def Greeting(obj):#obj,并没有被限定成什么类型的对象。任何对象都可以传入。只要他有SayHi方法
    obj.SayHi()

chen=Chinese()
vichin=American()
Greeting(vichin)

try:
    pass
except Exception as e:
    print('这里处理异常！')
else:
    print('可能会执行！')
finally:
    print('必定要执行的语句块！')

# 主动的抛出异常
# raise ValueError('主动抛出异常')

import contextlib

@contextlib.contextmanager  # 利用这个模块，可以将一个生成器快速的变成一个上下文管理器
def Test():
    print(1)  # 将yield之前的语句当做_enter_来执行
    yield
    print(2)  # 将yield之后的语句当做_exit_来执行


with Test() as x:
    print(3)  # 将这边当做中间部分来执行


@contextlib.contextmanager  #
def ShowError():
    try:
        yield
    except Exception as e:
        print('error:', e)


# 上下文管理器
with ShowError():
    print(16 / 0)  # 这里的语句将会替代上面的yield语句。在try中执行

import zipfile
exampleZip=zipfile.ZipFile("example.zip")#ZipFile要注意大小写。
exampleZip.namelist() #返回zip文件中所包含的文件与文件夹
#假定在压缩文件中存在spam.txt文件
spamInfo=exampleZip.getinfo("spam.txt")
print(spamInfo.file_size)#返回spam.txt文件的大小。单位byte
print(spamInfo.compress_size)#返回spam.txt文件压缩后的大小.单位byte
exampleZip.extractall()#将example.zip内的文件解压缩。如果给extractall方法传递了参数（路径），那么就会将文件解压缩到给定的文件夹中去。
exampleZip.extract("spam.txt")#对example.zip文件夹中的单个文件进行解压缩。给定的文件名称必须是在namelist中的。
exampleZip.extract("spam.txt","F:\book")
exampleZip.close()#不要忘记关闭流

#创建压缩文件，并将已有文件添加到创建的压缩文件中去
newZip=zipfile.ZipFile("new.zip","w")
#newZip.ZipFile("appendFile",'a') #向以有的ZIP文件中添加文件
newZip.write("spam.txt",compress_type=zipfile.ZIP_DEFLATED)
newZip.Close()#不要忘记关闭流

# openpyxl模块不是python自带的模块。
import openpyxl as xl

# 使用openpyxl模块中的load_workbook方法加载excel文件，前提是必须在当前环境下才行。如果不知道当前环境可以使用os.getcwd()来获取当前工作目录是什么，然后使用os.chdir()方法来改变当前工作目录。
wb = xl.load_workbook('example.xlsx')
# 使用get_sheet_names方法来获取当前excel中有多少个工作簿
print(wb.get_sheet_names())  # 返回['Sheet1', 'Sheet2', 'Sheet3']

sheet = wb.get_sheet_by_name('Sheet1')
print(sheet.title)  # 返回Sheet1

# 获取当前活动的工作簿（打开一个excel后，当前选中的工作簿即为活动的工作簿）
# activeSheet=wb.get_active_sheet()

print(sheet['B2'].value)  # 返回cherries
print(sheet.cell(row=2, column=2).value)  # 返回cherries

# 获取一块区域中的数据，并转换成元祖
tuple(sheet['A1':'B3'])
for rowOfCellObjects in sheet['A1':'B3']:
    for cellObj in rowOfCellObjects:
        print(cellObj.coordinate, cellObj.value)
    print('end of Row')
# 结果如下
# A1 22点21分
# B1 apples
# end of Row
# A2 22点22分
# B2 cherries
# end of Row
# A3 22点23分
# B3 pears
# end of Row

for cellObj in sheet.columns[1]:
    print(cellObj.value)

# 创建工作表
wb = xl.Workbook()
sheet = wb.get_active_sheet()
sheet.title = 'Spam Bacon Eggs Sheet'  # 修改当前活动的工作簿的名字
wb.create_sheet(index=1, title='second Sheet')  # 创建一个工作簿
wb.remove_sheet(wb.get_sheet_by_name('second Sheet'))  # 删除一个工作簿
sheet.cell(row=2, column=2).value = '中秋节快乐！'
sheet['A1'].value = '期待国庆节能够过的充实。'
wb.save('example1.xlsx')  # 保存excel

# 使用模板
excel = xl.load_workbook('example.xlsx')
sheet = excel.get_active_sheet()
sheet.title = 'spam spam spam'
excel.save('example_copy.xlsx')

# 需要事先安装python-docx模块，如果首次安装，可能时间会比较长。
# 在一个word文件中，一般分为3种类型的结构，最高一层的为Document，其表示整个文本。
# document中包含Paragraph对象的列表，表示文中的段落（用户在word文档中按下回车即表示新的段落开始）。
# 每个Paragraph对象中都包含一个Run对象的列表
import docx

doc = docx.Document('demo.docx')
print(len(doc.paragraphs))  # 文档中是一个标题加3个段落，所以该处返回的是4。
print(doc.paragraphs[0].text)  # 返回：文章标题
print(doc.paragraphs[1].text)  # 返回：    文章第一段的内容。这篇文章的目的：主要是用来测试如何在python中使用docx模块对word文档进行操作。
print(doc.paragraphs[1].runs[2].text)  # 返回：。这篇文章的目的：主要是用来测试如何在


def getText(fileName):
    doc = docx.Document(fileName)
    fullText = []
    for para in doc.paragraphs:
        fullText.append(para.text)  # 如果要将每一行内容都缩进的话，可以改写为：fullText.append('   '+para.text)
    return '
'.join(fullText)


# paragraphs的属性
doc.paragraphs[0].style = 'Normal'
# 默认word样式的字符串(在word文档中使用Shift+ctrl+Alt+S可以查看更多)：在设置样式的时候，若样式名称中出现空格，那么需要将空格给去掉。
# Normal  Caption ListParagraph   MacroText   NoSpacing   Quote   Subtitle    IntenseQuote    TOCHeading  Title
# BodyText    BodyText2   BodyText3
# Heading1    Heading2……Heading9
# List    List2   List3
# ListBullet  ListBullet2 ListBullet3
# ListContinue    ListContinue2   ListContinue3
# ListNumber  ListNumber2 ListNumber3

# run的属性
doc.paragraphs[1].runs[0].style = 'QuoteChar'
doc.paragraphs[1].runs[1].underline = True
doc.paragraphs[1].runs[3].underline = True
# run的属性列表
# bold italic(斜体) underline   strike（删除线） double_strike（爽删除线） all_caps（文本以首字母大写）
# small_caps（文本首字母大写，小写字母比大写字母小2个单位）  shadow（文本带阴影）
# outline（文本加轮廓线） rtl（文本从右至左书写）   imprint（文本刻入页面） emboss（文本突出页面）


doc1 = docx.Document()
doc1.add_paragraph('Hello World!')
paraObj1 = doc1.add_paragraph('This is a second paragraph')
# 使用add_run方法为已有段落的末尾添加文本
paraObj1.add_run('This text is being added to the second paragraph.')
doc1.add_heading('Header 0',0)#para1:标题样式，para2是标题层次（0表示title样式，适用于文档顶部，1是主要标题，4是最低层的子标题）
doc1.add_heading('Header 1',1)
doc1.add_heading('Header 4',4)
#使用add_break方法进行换行，如果传入了参数docx.text.WD_BREAK.PAGE则表示换页。
doc1.paragraphs[0].runs[0].add_break(docx.text.WD_BREAK.PAGE)
#使用add_picture方法在文档末尾添加图片
doc1.add_picture('lina.png',width=docx.shared.Inches(1),height=docx.shared.Cm(4))#宽度1英寸，高度4厘米
doc1.save('HelloWorld.docx')
#无论是paragraph还是run方法，都可以传入第二个参数，可以通过这个参数为插入的文本赋一个样式。

import csv

exampleFile = open('example.csv')
reader = csv.reader(exampleFile)
# data = list(reader)  # 转换成列表
# print(data[0][0])
for row in reader:
    print('Row #' + str(reader.line_num) + ' ' + str(row))

outputFile = open('output.csv', 'w', newline='')  # 打开一个文件（写模式）
outputWriter = csv.writer(outputFile)
#outputWriter = csv.writer(outputFile, delimiter='	',lineterminator='

')  # csv的write方法还有两个参数delimiter和lineterminator,前者表示使用制表符来隔开数据，后者表示使用两倍行距
outputWriter.writerow(['spam', 'eggs', 'bacon', 'ham'])
outputWriter.writerow(['hello,world!', 'eggs', 'bacon', 'ham'])
outputWriter.writerow([1, 2, 3.141592657, 4])
outputFile.close()

import json

#将json对象转换成python对象
stringOfJsonData = '{"name":"Zophie","isCat":true,"miceCaught":0,"felineIQ":null}'
jsonValue=json.loads(stringOfJsonData)

#将python对象转换成json对象
pythonValue={'isCat':True,'miceCaught':0,'name':'Zophie','felineIQ':None}
strValue=json.dumps(pythonValue)

如何在Windows上打包发布python程序：https://blog.csdn.net/caimouse/article/details/52021193