【针对性复习】Python

愿我们相会于
    世界腾飞之时！

目录

• Python概念
• 基本语法
• 序列和字典
• 深浅拷贝
• Python文件的操作

---

Python是什么？

Python之禅：The Zen of python!   <Beautiful is better than ugly.>

1、#pip：包管理器  .maven/yum

import qrcode //qrcode,默认是没有的，第三方库-----

qrcode.make('今天要放假啦').save('./text.png') qrcode：生成为二维码 \

ps: python 动态类型的编程语言，在编译过程中类型可以发生改变

2、#print/type 内建函数

   #字符串前面加一个r表示原始字符串(raw_string)字符串内部的转义字符不生效；
name=r"my 'name' '' 'is 'ranxiaoxi' "

name ="abcdef"

print(name[-3])
    #字符串下标可以取负数 -1=len-1 <下标不可以越界>

print(name[1:3])
    #取字符串子串.1:3[1,3)区间 ----切片操作(slice);

print('='*30) 打印分割线
    #Python只有字符串类型，没有字符类型
    #布尔类型也是一种特殊的类型，

value=true

print(type(value)) // 打印类型
    # Python同样遵守短路求值《概念了解》
    #Python中没有++/-- 这样的操作
    #python中的列表（list）中存的元素可以是任意类型的，

list(列表):a=[9,2,3,'haha',[2,4],6]
    #元组(tuple)，列表是可变对象，元组是不可变对象
tuple(元组)：a=(1,3,4,5,6,"haha")
    #字典 ：a{ }
a={
#键值对：
   'ip':'127.0.0.1' #环回IP
    'port':80
}

a=1

b=2
print(a/b)

#列表（list）

a=[1,2,4,5,3,6]
a[0]=99
print(a)

#元组（tuple）
#列表是可变对象，元组是不可变对象
    #不可变对象有一个好处就是“线程安全”！

a=(1,2,3,"haha",7)
#字典
a={
   'ip':'127.0.0.1' #环回IP
}

print(a['ip'])

#id这个内建函数，查看变量的“地址”

a='haha'
a=b
print(id(a))
print(id(b))

#代码块缩进
result = input('你愿意认真运动吗？ 1 表示愿意 0 表示不愿意')
if result == '1':
    print('你会有好身材！')
elif result == '0':
    print('你会变胖的')
else:
    print('输入有误！！！') 

 #while循环
num=1
while num<=10:
    print(num)
    num += 1  
for num in range(0,11):
    print(num) 
a={'ip':'127.0.0.1','port':80}

for key in a:  #前闭后开区间

    print(key,a[key])

    #python中同名函数会相互覆盖，没有重载这样的规则
    #一个函数可以返回多个值

读操作：
f = open('d:/test.txt','r')

#返回一个列表
#a=f.readlines()
for line in f:
   print(line,end='')
f.close()

写操作：
f = open('d:/test.txt','w')
f.write('hello world!')
f.close()

#shell文件操作是更简单的.

f = open('d:/test.txt','r')
word_dict={}
for word in f:
    #strip str的方法，功能是去掉字符串的头和尾的空白字符
    #空白字符：空格，制表符，换行符，垂直制表符，翻页符...

    word = word.strip()
    if word in word_dict:
        word_dict[word]+=1
    else:
        word_dict[word]=1
f.close()

print(word_dict)

3、模块：

• 通过import关键字，引用其他.py文件的代码

• 被引入的代码文件，被称之为“模块”

• 去掉 .py 后缀名，就是模块名

4、语句折行：

双引号和单引号都不能折行，但是三引号可以折行使用

5、python关键字：

_xxx表示一个python的“私有变量”

6、对象和类型

• 一切都是对象

• python中任何类型的值其实都是一个对象判断一个东西是否是对象时（就尝试用id去一下看能否取到）

• 类型也可以是对象

• python是纯粹的面向对象

7、【深浅拷贝】

浅拷贝是指, 虽然我重新创建了一个新对象, 但是新对象里面包含的子对象, 和原来的子对象是同一个对象.

深拷贝就是指, 重新创建了一个新对象, 同时这个新对象的子对象, 也都是重新创建了一份新的深拷贝对象.

深拷贝通过 copy.deepcopy 来完成；但是对于可变对象（list、dict）才能深拷贝,而对于不可变对象，只能浅拷贝

import copy

a=[1,3,2]
b=copy.deepcopy(a)
a[0]=99
print(a) #[99,3,2]
print(b) #[1,3,2]-----改动a不会影响到b的结果<深拷贝的含义>

理解对象和类型：

• 相同的类型的对象, 须有相同的操作. 比如, 所有的整数对象, 都可以进行加减乘除操作. 所有的字符串都可以使用切片操作.

• Python是一种 动态强类型 编程语言.

• 动态类型是指运行时进行变量类型检查;静态类型:一个变量在运行过程中类型不可以发生改变； 强类型 指类型检查严格, 并且"偏向于"不允许隐式转换.

• 类似的, C语言是一种静态弱类型语言. Java的类型检查更为严格, 一般认为是静态强类型, 而Javascript则是动态弱类型。

标准类型

• 整型

• 浮点

• 复数型

• 布尔型

• 字符串

• 列表

• 元组

• 字典

其他内建类型

• 类型

a=20
    #type就是一个对象，这个对象的类型就是一个type类型。
b=type(a)
print(b)

• Null对象(None)

• 文件

• 函数

• 模块

• 类

内建类型的布尔值

所有的标准对象, 均可以用于布尔测试(放到if条件中).

下列对象的布尔值是False

• None

• False

• 所有值为0的数字(0, 0.0, 0.0 + 0.0j)

• "" (空字符串)

• [] (空列表)

• () (空元组)

• {} (空字典)

if {}: #空字典为False
    print('heihei')
else:
    print('haha')

类型工厂函数   vs  单例模式

• int() ,float(),complex()这都是内建函数

单例模式的特点：

• 单例类只能有一个实例

• 单例类必须自己创建自己的唯一实例

• 单例类必须给所有其他对象提供这一对象实例
• 单例模式常见的写法有: 懒汉式单例，饿汉式单例

Python不支持的类型

• char, byte: 可以使用长度为1的字符串, 或者整数代替;

• 指针: Python替你管理内存, 虽然id()返回的值接近于指针的地址, 但是并不能主动去修改;

• int/short/long: 以前版本的Python中也是区分int和long的, 但是后来统一在一起了; 记住Python中的整数表示的范围, 只取决于你机器内存的大小.

• float/double: Python的flfloat其实就是C语言的double. Python设计者认为没必要支持两种浮点数.

常用内置函数/模块

import math
#print(math.pi)
for i in range(0,10):
    print(round(math.pi,i)) #round：对浮点数进行四舍五入，round有两个参数，一个是要进行运算的值，第二个是保留的小数点后的位数

import random 
#随机种子
print(random.randint(1,6))

函数和可调用对象

def outer():
    def inner():
        print('haha')
    inner()

#函数也是一个对象，“可调用对象”
outer()

函数的参数

def add(x,y):
    return x+y
print(add('hello',' world'))
print(add([1,2],[3,4]))
print(add(11,23))

def log(*data):    #*data表示多个参数
    for i in data:
        print(i,end='、')
log(11,12,13)

def log(**data):        #**data相当于字典
    for key in data:
        print(key,data[key])
log(x=1,y=2,z=3)

关键字参数

def print_point(x=0,y=0,z=0):
    print(x,y,z)
print_point(x=99,z=98)

print(10,20,end='',sep='-')

自定制排序规则：

a=[1,4,9,6,2]
b1=sorted(a)                 #升序排列
b2=sorted(a, reverse=True)   #降序排列
print(a,b1)
print(a,b2)

序列类型操作符

• 连接操作符(+): 把两个相同类型的序列进行连接.

连接操作符往往并不高效(新创建对象, 把原有对象拷贝进去). 对于列表, 推荐使用extend来完成这样的操作; 对于字符串, 推荐使用join这样的方法.

a=['aaa','bbb','ccc']
result = '-'.join(a)
print(result)

a='hesolp'
print(sorted(a))
print(''.join(sorted(a)))

重复操作符(*):让一个序列重复N次

a=[1,2,3,4]

print(a*10)

a=[1,2,3,4,5,6,7,8]
print(a[::-1])      #逆序打印

print(a[::2])
print(a[::4])
print(a[::1])

序列内建函数：

• enumerate: 同时枚举出序列的下标和值. 这个是一个非常有用的函数, 可以避免很多丑陋的代码.

回忆我们之前写过的, 找出元素在列表中的下标.

def Find(input_list, x):
for i in range(0, len(input_list)):
if input_list[i] == x:
    return i
else:
    return None

这里我们的for循环写的就不够优雅, 使用enumerate可以得到一种更优雅的写法.

def Find(input_list, x):
for i, item in enumerate(input_list):
if item == x:
    return i
else:
    return None

• zip: 这个函数的本意是 "拉链", 我们先看代码.

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9, 10]
print(zip(x, y, z))

# 执行结果
[(1, 4, 7),
 (2, 5, 8),
 (3, 6, 9)]

• zip其实可以理解成矩阵的行列互换。

• zip的一个比较常见的用法，就是构造字典。

 

---

0、erlang特别适用于并发的场景

1、

a=10
s=f'a={a}'

print(s) //字符串的转换

2、python原始字符串：<raw，原始的>

a=r'hello\n world'
print(a)
    C++ 原始字符串：R"(hello)"

3、字符居中，排版适用

a='hello'
print('['+a.center(60)+']')
print('['+a.ljust(50)+']')
print('['+a.rjust(50)+']') #中左右对齐

4、字符串切分

a='hello world haha heihei'
print(a.split(' ')) #空格分隔

a='hello world haha heihei'
b=a.split(' ')
print(';'.join(b)) #分号分割

5、关于列表

    #字符串只能由字符组成，而且不可变；列表可以包括任意类型的对象，是可变的。

6、append（插入）

a=[1,2,3,4]
a.append([5,6])   #append追加操作，将5追加到列表末尾
print(a)
print(len(a))

7、删除

a=[1,2,3,4]
del(a[1])   #可以删除任意位置的元素（按下标删除）
a.remove(2) #删除元素（按值删除，有多个相同的元素，删除第一出现的元素）时间复杂度O(N)
print(a)

8、排序

a=[1,2,3,6,4]
print(sorted(a))
print(a.sort()) #会修改原列表

print(a)

9、基于列表的堆栈

a=[1,2,4,3]
a.append(5) #push操作
print(a)
a.pop(0)
print(a)

10、元组的使用：

• 由于元组不可变，所以不支持append、extend、sort等修改自身的操作

• 元组的不可变指的是元组的每个元素的id不可变，就是说元组内部包含着可变对象，这样的可变对象是能修改的，但是该对象的id是不能发生变化的

• 你有一个列表, 现在需要调用一个API进行一些处理. 但是你有不是特别确认这个API是否会把你的列表数据弄乱. 那么这时候传一个元组就安全很多.

• 我们马上要讲的字典, 是一个键值对结构. 要求字典的键必须是 "可hash对象" (字典本质上也是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行.

a=([1,2],[3,4])
a[0][0]=99
print(a)



a=(1,2,3)
a=a+(4, )  #元组的插入
a=a+(4)   #这样的操作是错误的！！！切记
print(a)   

11、字典：字典存的是键值对结构，其中键必须是不可变对象 && 可哈希。<可变对象一般是不能哈希的>

a={
   'ip':'127.0.0.1',
   'port':80
  }
a['port']=100
a['hello']=11 #存在即修改，不存在即插入
print(a)


a={
   'ip':'127.0.0.1',
   'port':80
    }
print(a['port'])
for key in a:
    print(key,a[key])
print(a.keys())
print(a.values())
print(a.items())

• 如果直接对字典进行赋值操作，可以直接取key来设置；如果只能查找操作，最好先判定key是否在字典中存在存在即取值，不存在抛异常；

• len: 字典中键值对的数目

• hash: 判定一个对象是否可hash. 如果可hash, 则返回hash之后的hashcode，否则运行出错

12、集合

集合是基于字典实现的一个数据结构，集合数据结构实现了很多数学中的交集、并集、差集等方法。

a=set([1,2,3])
b=set([3,2,1])
print(a == b) #集合的概念和顺序无关


a=set([1,2,3,3,2])
print(a) #集合不可以重复，打印{1,2,3}

a=([1,2,3,3,2])
b=list(set(a)) #将a构造成集合，list成列表
print(b)

---

Python文件的操作

1、文件具备随机访问能力，这个过程是通过操作文件指针完成的。

import os.path
my_path='d:/aa/bb/cc.txt'


print(os.path.basename(my_path))  #可获取到文件名
print(os.path.dirname(my_path))
print(os.path.split(my_path))   #可分离出扩展名
print(os.path.splitext(my_path))  #可分离出文件后缀名
【测试压缩文件的测试用例，分离出不同类型的文件】

2、walk()，生成一个目录下的所有文件名

import os
my_path='d:/aa'
for item in os.walk(my_path):
    print(item)

#按路径打印
import os.path as op
import os
my_path='d:/aa'

#把目录下所有的文件打印出来
for base_path,_,files in os.walk(my_path):
    for f in files:
        print(op.join(base_path,f))

3、捕捉异常

(一)

try:
    a=[1,2,3]
    print(a[100])
except IndexError as e:
    #print(type(e))
    print(e)
else:
    print('没有异常发生')

(二)
try:
    a=[1,2,3]
    prin(a[1])
except Exception as e: #Exception 所有异常的集合表示
    print('出现异常了')
else:
    print('没有异常发生')

(三)
#pylint 代码静态检查工具
def devide(x,y):
    if y == 0:
        #raise 10
        raise Exception('divide zero except')
    return x/y
try:
    devide(10,0)
except Exception as e:
    print(e)
def test():
    divide(10,0)
try:
    test()
except:
    print('捕获异常')

4、with就是try  except  finally的简化写法（看课件）

5、Python在查找模块的时候，在指定目录中查找的

import sys
for path in sys.path:
    print(path)

6、import语句

import sys
import os
def func():
    import os.path
    ret = os.path.exists('d:/aa.txt')
    print(ret)
func()

#import是导入整个模块
#from import 导入模块中的指定名字

import sys
import os.path as op
def func():
    ret = op.exists('d:/aa.txt')
    print(ret)
func()

下面两个含义一样的，但是用法不一样。

from os.path import *---不建议使用，用谁就导入谁
import os.path

---

7、模块的内置变量

print gllobals() #打印全局变量
if __name__ == '__main__':

    #以下这部分代码是可以作为测试代码：
    #如果 calc 是作为一个模块被其他文件调用的话，就不需要执行这部分代码了
    #如果直接执行 calc 文件，那么此时测试代码就可以被执行到

print(add(10,20))
print(sub(10,20))
print(mul(10,20))
print(divide(10,20))
__builtins__ : 内建函数模块. 包含了open, help, doc等内建函数的定义
__name__ : 模块名字. 如果是从这个模块开始执行, 那么 __name__ 值为 __main__
__file__ : 模块的文件名
__doc__ : 模块的文档字符串
__package__ :模块从属的包名

8、包（package）

• 所谓包就是一个特殊的目录

• 里面必须包含一个 __init__ .py 文件

• 这个文件负责对包进行初始化

import calc_math.calc

print(calc_math.calc.add(10,20))

9、sys模块

• sys.executable: Python解释器的绝对路径.

• sys.exit(): 退出Python.

• sys.getsizeof(): 获取一个对象占用的内存空间大小（字节）

• sys.modules: 一个字典对象, 描述了当前程序都加载了哪些模块(模块名为key, 模块对象为value).

• sys.path: 模块查找路径, 一个列表.

• sys..platform:一个字符串的对象，操作系统标识符。

10、os模块（混杂的操作系统接口，跨平台的能力）

• 进程信息

11、Python面向对象编程（OOP）

• 面向过程：编年史

• 面向对象：记传史

• python中的对象包含三个部分:id ,类型，值。

12、封装和接口

• 封装就是让类的调用者不需要了解类的实现者是怎么实现的。封装是为了让调用者使用起来更方便，成本更低。例如：手机通话是怎样实现的？

class Test:
    """
    这是一个用来测试类创建语法的类
    """
    def Print(self):

        '''
        实例方法:成员函数/普通函数
        '''
        print('hello')
test = Test()
test.Print()
Test.Print(test)

• 接口就是类的实现者提供给类的调用者去使用的内容。

13、组合/包含

• 组合：has-a 语义

• 组合的目的就是，代码复用

14、继承/派生

• 继承： is-a

• 继承的目的还是，代码复用

组合的场景远远多于继承！

15、多态

• 多态是封装的更进一步，调用者既不需要知道实现者是怎么实现的，也不需要知道实现者实现的这个类是什么类型的。

16、自省/反射

17、属性和方法

创建类：

class Test:
    """
    这是一个用来测试类创建语法的类
    """
    def Print(self):
        '''
        实例方法:成员函数/普通函数
        '''
        print('hello')

test = Test()
test.Print()
Test.Print(test)

18、属性的访问权限

• Python中使用双下划线（__xxx）前缀来表示私有成员；

19、继承

• 子类可以继承父类的属性和方法

• 父类和子类中出现同名方法或者属性的时候，子类会覆盖父类的属性和方法；

• 没有显示调用父类构造器，执行报错。

class Parent(object):
    def __init__(self):
        self.x = 100
class Child(Parent):
    def __init__(self):
        Parent.__init__(self)   # 显式调用父类的方法.
        self.y = 200

p = Parent()
print(p.x)
c = Child()
print(c.x)

19、Python中继承和多态没有太多的联系

• Python中的多态就是从函数实现这角度看，并不知道具体类型，只知道可以实现某种功能，不管是啥类型都可以在一起操作

• 基于'鸭子类型'的多态----更加广义的多态，

20、类和实例的常用内建函数

• issubclass：判定一个类是否是另外个类的子类；

• isinstance：判定一个对象是否是一个类的实例；

• hasattr,getattr,setattr,delattr：用来对一个类/对象的属性进行操作和判定；

• dir：查看类/对象的所有属性和方法；

• vars：和dir 类似，不过vars 将值取出来了；

• supper：获取当前类/对象的父类；super本质上也是一个工厂函数，创建一个父类的对象。

 21、特殊方法指定类

class Time(object):
    def __init__(self,hour,min):
        self.hour = hour
        self.min = min

    def __str__(self):
        return f"{self.hour}:{self.min}"

    def __len__(self):
        return len(f"{self.hour}:{self.min}")

t = Time(12,32)
print(t) #打印时间
print(len(t))

~未完待续~