Python

什么是Python

python是纯粹的自由软件， 源代码和解释器CPython遵循 GPL(GNU General Public License)协议。Python语法简洁清晰，特色之一是强制用空白符(white space)作为语句缩进。

Python具有丰富和强大的库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的最终界面），然后对其中有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C/C++重写，而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。

关于

暑假了，对自己两个月的Python学习做一个复习总结，我会把文章内的所有内容都上传到我的github上，对于一些Python的内容进行简单的介绍和复习。

Python的编码风格------PEP8

对于Python这门语言，他有一套专门属于自己的编码风格（PEP8），这可以使Python的代码更加的简洁，口感更好。

Python之禅

import this 

运行这个.py文件就会出现python之禅

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Python变量

与其他一些语言不同的是，在Python的变量中，无需在赋值的时候进行任何的类型声名。

num = 2  #整数变量
string = 'dsds'
char = '2'
num_float = 1000.0
list=['d',2]
tuple = ('dsds',char)#元组
dict = {'3','ds'}
dict1 = {'3':'ds','ds':"ds"}
print(type(num),type(string),type(char),type(num_float))
print(type(list))
print(type(tuple))
print(type(dict))#字典必须满足键值对的要求，如果字典里面只有key而没有value,则类型未set类型
print(type(dict1))

占位符

#打印字符串
name = 'jonnh'
age = 2
print('hello,my name is %s'%(name))#单个
print('hello my name is %s,my age is %d'%(name,age)) #多个
print('hello,my name is %s'%('jack'))
print('hello my name is %s,my age is %d'%('jack',20))
print('hello my name is %10s,my age is %.2f'%('jack',2.345435345))
#format
print('hello my name is {0} ,my age is {1},{1},{1}'.format(name,age))
p=['joon',2]
print('{0[0]},{0[1]}'.format(p))

条件语句与循环语句

#if语句
if 1 < 3:
    print(False)
else:
    print(True)

if 1>3:
    print(False)
elif 1<4:
    print("虽然1>3是错的，但是1<4是对的")
else:
    print(True)

#for语句
list = []
for i in range(10):
    list.append(i)
print (list)

#while
num = 1
while True:
    num+=1
    if num>10:
        break
print (num)

三元操作符

#三元操作符
a = 'x' if 1<6 else 'y'
print (a)
#相当于
if 1<6:
    a='x'
else:
    a='y'

断言

#断言(assert）
assert 3>4 ,'3不大于4'

语句:assert 条件，提示
    如果条件成立，则不执行提示
    如果条件不成立，则执行提示

列表

list = [1,2,3,45,6]
#添加元素
list.append('添加一个元素')
#添加列表
list_extend=['元素1',2]
list.extend(list_extend)
print(list)
#插入元素  list.insert(位置,元素)
list.insert(0,'0')
print(list)
#取值
print(list[0])
#删除元素 
#根据元素值  list.remove(值)  
#根据元素的位置 del list[位]
#删除最后一个元素
list.remove('0')
print(list)
del list[0]
print(list)
list.pop()
print(list)
#切片
print(list[0:2])

函数

def func(name): #传形式参
    print (name)
func("jhoon")  #传实参

#函数文档
def funcc(age):
    """
    输出我的年龄的函数
    """
    print("我的年龄是:%s"%(age))
funcc(20)
print(funcc.__doc__)
print(help(funcc))

#收集参数
#Python中有两个收集参数的工具，一个*args另外一个是**kwargs
def funccc(*arg):
    print(arg[1])
    print(arg)

funccc('2','3','4')
def funcccc(**kwargs):
    print(kwargs)
funcccc(c=1,a="2")
#当然这里的args和kwargs只是官方定义的名称，你可以改成任何你喜欢的词语
def f(**k):
    print(k)

f(c=1,a="2")


#可以返回多个值，但是最终这些值都会以元组的形式输出
def test():
    return 1,2,3,4,5
print(test())


#一般情况下，你的函数内只允许调用全局变量和创建局部变量来使用，这样我们可以保护我们的全局变量，但是有时候我们实在需要在函数内部去改变函数外的全局变量的
#这个时候我们需要用到global
count = 8
def test_count():
    count = 10
    print(count)
test_count()
print(count)
#上面并没有改变
count = 9
def test_global():
    global count
    count = 10
    print(count)
test_global()
print(count)


#闭包，闭包即将函数当作变量来使用
def funA(a):
    def funB(b):
        return b*a
    return funB
i = funA(2)
print(i(4))
#这里看funB  我们将a*b的值赋值给了funcB，再将funB的值赋值给了funA，于是结果就是8，在这里函数变成了带值的变量，注意这里返回的是函数，而不是函数（）

#nonlocal  和golbal相似 golbal用户重新改变全局变量的值，而nonlocal用于改变外面一层的值
def funAA():
    a = 10
    def funBB():
        nonlocal a
        a = 5
        return a*a
    return funBB
funAA()()

#匿名函数lambda
g = lambda x : x*2+1
x = g(5)
print(x)

Python文件处理

文件对象的方法

open(file,mode='r',buffering=-1,encoding=None,errors=None,newlane=None,closefd=True,opener=None)

文件操作

因为是入门Python,所以我只介绍file和mode两个内容

file是文件的名字更具体的是路径加上文件名，但是如果不带路径的话，Python会在当前文件夹中寻找

如果我们寻找的文件本身就不存在，这时候我们就要设置mode的值

模式 操作
'r' 以只读的方式打开文件（默认）
'w' 以写入的方式打开文件，会覆盖已存在的文件
‘x’ 如果文件已存在，用该模式打开会出现异常
‘a’ 以写入的方式打开文件，如果文件已经存在，会在末尾追加写入
‘b’ 以二进制模式打开文件
't' 以文本模式打开（默认）
‘+’ 可读写模式（可添加到其他模式中使用)
'U' 通用换行符支持

其他方法

文件对象的方法 操作
close() 关闭文件
read(size=-1) 从文件读取size个字符串，当未定size或给定负值的时候，读取剩余的所有字符，然后作为字符串返回
readline 从文件中读取一整行字符串
write(str) 将字符串str写入文件中
writeline(seq) 向文件写入字符串序列seq,seq应该是一个返回字符串的可迭代对象
seek(offset,from) 在文件中移动文件指针，从from(0代表文件的起始位置,1代表当前位置，2代表文件末尾)偏移offset个位置
tell 返回当前在文件中位置

f = open('test.txt',mode='a+',encoding='utf-8')
f.writelines("这是第二段内容\n")
f.close()
with open('test.txt',mode='r',encoding='utf-8') as ff:
    zz = ff.readline()
    print (zz)

with open('test.txt',mode='r',encoding='utf-8') as ff:
    cc = ff.read(10)
    print (cc)

OS模块

函数名 使用方法
getcwd() 返回当前工作目录
chdir(path) 改变工作目录
listdir(path='.') 列举指定目录中的文件名(‘.’表示当前目录,'..'表示上一级目录)
mkdir(path) 创建单层目录，如果目录已存在抛出异常(即创建文件夹)
makedirs(path) 递归创建多层目录，如果该目录已存在则抛出异常，注意:'E:\a\b'和‘E:\a\c’并不会冲突
remove(path) 删除文件
rmdir(path) 删除单层目录，如果该目录非空则抛出异常
removedirs(path) 递归删除目录，从子目录到父目录逐层尝试删除，与目录非空则抛出异常
rename(old,new) 将文件old重命名为new
system(command) 运行系统的shell命令
os.curdir 指代当前目录
os.pardir 指代上一级目录
os.sep 输出操作系统特定的路径分隔符(在windows下为‘\’,linux下为'')

import os
str = os.getcwd()
print(str)#显示当前目录

#2.更改当前工作目录
os.chdir("E:\\") 
print(os.getcwd())

#3.列举当前目录中的所有文件名
str_list = os.listdir()
print(str_list)


# #4.创建目录，创建文件夹，单层
# os.mkdir('test')
# print(os.listdir())

#5.使用windows里面cmd或者linux下的shell
os.system('calc')

Python异常处理

一些异常报错

#异常处理

# #AssertionError报错
# a = 10
# b = 1
# assert b>a,'不好意思,b大于a是错误的'

# #IndexError索引超出序列的范围
# list=[1,2,3,4]
# print(list[7])

# #keyError:字典中查找不到一个存在的关键字
# dict = {'a':3,'b':4}
# print(dict['c'])

# #NmaeError：尝试访问一个不存在的变量
# name = 2
# print(name1)

#OSError操作系统产生的异常
import os
os.mkdir('test.txt')

#SynaxError：Python的语法错误
#TypeError:不同类型的无效操作

异常捕获 try-except

#异常捕获
try:
    检测范围
except Exception[as reason]:
    出现异常(Exception)后的处理的代码

try:
    dict = {'a':3,'b':4}
    print(dict['c'])
except KeyError:
    print("不好意思啦，不存在C这个key值")

如果你不清楚是什么错误，你可以这样写

try:
    dict = {'a':3,'b':4}
    print(dict['c'])
except KeyError as reason:
    print("不好意思啦，不存在C这个key值,错误的地方是"+str(reason))

try-except-finally

#异常捕获
try:
    dict = {'a':3,'b':4}
    print(dict['c'])
except KeyError as reason:
    print("不好意思啦，不存在C这个key值,错误的地方是"+str(reason))
finally:
    dict['c'] = 5
    print(dict)

自己抛出异常 raise 错误类型(错误提示)

raise NameError('不好意思错误了')

#self相当于指针用来调用类对象内的属于自己的东西
#__init__(self)是构造方法,在创建一个类的时候如果你需要去定义一些基本的属性，就可以在类
#下面去定义init(self)类型,但同时在实例化案例的时候需要填入一些参数。

# class dog:
#     def __init__(self):
#         self.name = "小花"
#         self.age = "6"
#     def act(self):
#         print("我叫{0},我的年龄是{1}".format(self.name,self.age))

# dogA = dog()
# dogA.act()

class dog:
    def __init__(self,name,age):
        self.name = name 
        self.age = age
    def act(self):
        print("我叫{0},我的年龄是{1}".format(self.name,self.age))

dogA = dog('小草','20')
dogA.act()

#公有和私有
#和其他语言一样，对象是具有公私属性的，但是默认是公开的
#在Python 中定义私有变量只需要在变量名或函数名前面加上"__"两个下划线，那么这个函数或变量
#就会成为私有的

class Dog:
    name = "小驼"
d = Dog()
print(d.name)

# class DogA:
#     __name = "小驼"
# d = Dog()
# print(d.__name)  #这个时候你就无法访问里面的内容了，你只能在内部引用

class DogB:
    def __init__(self):
        self.__name = "小托"
    def printName(self):
        new_name = self.__name
        print(new_name)
        new_name = "小小"
        print(new_name)
zz = DogB()
zz.printName()
#但是Python的私有机制其实是伪私有，Python的类是没有权限控制的,所有的变量只是Python动了一下手脚，
#外部使用的时候，完全可以用_类名__变量名即可访问双下横线的私有变量
# print(zz._DogB__name)



#继承
#语法:       class 类名(被继承的类)
class Pick:
    def tell(self):
        print("Hello,我是父元素") #父方法

class PickA(Pick):
    def tell(self):
        print("Hello,我重写了父元素的tell方法,现在我是child")


class PickB:
    pass

pic = Pick()
pic.tell()
pica  = PickA()
pica.tell()

#多重继承
class Base1:
    def run1(self):
        print("我继承了bASE1")
class Base2:
    def run2(self):
        print("我继承了base2")
class Base(Base1,Base2):
    def run(self):
        self.run1()
        self.run2()

b = Base()
b.run()


#Minxin类实现多重继承
#1.首先他必须要表示一种功能，而不是某个物品，
#2.其次他必须责任单一，如果有多个功能，就写多个Mixin类
#3.他不依赖于子类的实现，
#4.最后，子类即便没有继承这个Mixin类，也照样可以工作，就是缺少了
#某个功能
class people:
    def __init__(self):
        self.name = "小白"
        self.age = "19"
    def tell(self):
        print("我叫{0},我今年{1}".format(self.name,self.age))

class WalkMixin:
    def walk(self):
        print("哈哈哈，我使用了Mixin添加了功能，现在我可以走了")

class health(people,WalkMixin):
    pass

h = health()
h.tell()
h.walk()