python学习笔记

前言

学习笔记是通过一个code.mosh的视频网站学习的，以下是学习记录。学习编程最好的方式还是敲代码。感觉python真的是借鉴了很多语言，比如java,js,erlang。这是我接触过的语言，感觉python都有用到。

start

VScode和anaconda配置

用VScode搭配anaconda作为PYTHON的IDE环境感觉非常不错。

首先Vscode安装python 插件

pylint插件是用来检查语法错误并给与改正一件，设置方法：打开view->palette->l输入lint 然后选择pylint
autopep8 插件是自动format code 的插件，安装之后再vscode - preference - setting - format on save 中把 format勾上就可以在每次保存的时候自动format代码非常方便。当然也可以每次手动格式化代码然后保存。

anaconda配置python环境

安装anaconda，他的优势就是可以直接可视化的安装python环境和依赖包，非常简洁。想安装python3.7可以直接选择然后在此配置中选择项想要安装的依赖包，已安装的都会显示在anaconda上。

编译运行文件

点击VScode左下方的版本选择python版本，这时就会发现anaconda已经配置好的Python环境了，选择anaconda配置好的比如py3.7版本。然后这时你的环境就会切换到这里。如果想要运行python2这里直接切换选择就可以。

运行文件

新建app.py

# Suppose this is foo.py.
import math
print("before import")

print("before functionA")


def functionA():
    print("Function A")


print("before functionB")


def functionB():
    print("Function B {}".format(math.sqrt(100)))


print("before __name__ guard")
if __name__ == '__main__':
    functionA()
    functionB()
print("after __name__ guard")

before import
before functionA
before functionB
before __name__ guard
Function A
Function B 10.0
after __name__ guard

python是脚本语言所以可以直接运行，不像java需要从main函数中运行代码。python会按顺序执行代码，main方法也是执行入口，但是main方法要写到所有其他声明的最后，如果放在调用方法之前则找不到要调用的方法。这点不像java或javascript

右键该文件选择在终端运行该文件，这时terminal会切换到anancoda python3上。也就是在此环境上的terminal，上面会有python标识，而不是bash标识。如果你安装了pip可以检查pip --version会发现是在python3环境下的。如果你想安装的依赖包比如说gym这个包，在anaconda下是没有这个第三方包的，可以根据官网提示安装方法pip install gym他就会在anaconda python3的环境下安装此包。

所以你的电脑本身是不需要安装Python的，anaconda都帮你集成好了。

python 基础语法

python 的数据类型：

前三者是基本数据类型，后四个是集合类型（引用类型）

• bool (True or False)
• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Set（集合）

## 下划线命名，无需分号结束本行
student_count = 1000  # integer
rating = 4.99  # float
is_publish = False  # bool
couse_name = "asdf"  # string
# 多行string，这里定义什么格式，输出就是什么格式
mutiple_line = """ 
aj;lkn
kajnsg
asng
"""

# 连续赋值
x, y = 1, 2
x = y = 1

## 可以在赋值的时候指明变量类型，但是由于python是动态语言所以还是会修改age的类型，但是这样可以注明变量类型。
age: int = 20
age = "pyt"
print(age)

静态与动态语言

静态语言：java，c++,c#
动态语言：Python，javascript
区别是静态语言必须指定变量类型而且不能够改变变量类型是在编译时候确定，动态语言是无需指明变量类型而且在之后可以改变变量的类型，变量类型在运行时候确定。
查看python变量类型可以把鼠标放在变量上，或者利用type语句来检查。

可变类型与不可变类型

这里整数是不可变类型，分配给他内存之后内存就不可以改变。基本类型变量是不可变类型。
引用类型比如数组是可变类型，可以在这个内存上继续改变。

x = 1
print(id(x))  # 4420295856 地址

x = x+1
print(id(x))  # 4420295888 给x分配了新的内存

y = [1, 2, 3]
print(id(y))  # 4530339720

y.append(4)
print(id(y))  # 4530339720

string

字符串剪切

course = "python programming"
print(len(course))#得到字符串长度
print(course[0])#得到第一个字母
print(course[-1]) # 会打印从后往前数的对应字符
print(course[0:3]) # 剪切包括0不包括3的字符串
print(course[:3])
print(course[0:])
print(course[:]) # 会得到一个新的字符串地址和之前的不同

print(id(course)) 
print(id(course[0])) # 会新建一个内存存储新字符串，因为string是不可变变量

''' 这是多行注释
18
p
g
pyt
pyt
python programming
python programming
4409501424
4409246696
'''

formatted string 格式化字符串

first = "charles"
last = "ren"
full = f"{first}    {last} @{2+2}" # 前面加f才可以作为格式化，{|}才是变量
print(full) # charles    ren @4   有点像js中的语法大括号{}中放变量


course = "  Python Programming"
print(course.upper())  # PYTHON PROGRAMMING
print(course.lower())  # python programming
print(coures.title()) # Python Programming 驼峰命名
print(course.strip())  # Python Programming  可以去掉前面的空格
print(course.find("Pro"))  # 9 找到位置，如果找不到返回-1
print(course.replace("P", "-"))  # -ython -rogramming
print("Programming" in course)# True


# 三个点包围，可以作为字符串赋值给变量，也可以单独作为注释
mutiple_line = """ 
aj;lkn
kajnsg
asng
"""
'''
  PYTHON PROGRAMMING
  python programming
Python Programming
9
  -ython -rogramming
True
'''

number

x = 0b10010
print(x)  # 18 输出十进制
y = 18
print(bin(y))  # 0b10010 输出二进制

# 十六进制
a = 0x12c
print(a) # 300
b = 200
print(hex(b))  # 0xc8


x = 10//3  # 10 / 3取整数部分
x = 10 % 3  # 10 /3 取余数
x = 10**3  # 10的三次方

# python中没有x++ 或者x--
x = x+1
x += 1
print(x)

PI = 3.14  # 利用全部大写字母代表const，因为python里没有const
print(round(PI)) # 取整数部分

类型转换和Falsy

x = input("x: ")  # 键盘输入,因为键盘输入的是str类型
# 由于输入的类型不能确定所以需要告诉编译器需要转化成的类型，他不会自动转化，所以python是强类型语言，必须显示转换而javascript可以隐式转化所以他是弱类型语言
print(int(x)) # 转换
print(float(x))
print(bool(x))
print(str(x))

# Falsy: String "" , 数字0 , 数组[], 对象None , 布尔False

if语句

age = 10
if age >= 18:
    print("Adult") # 如果想为空则需要用pass关键字
elif age >= 13:
    print("Teenager")
else:
    print("Child")

print("all done")

逻辑表达式

name = " " # not关键字是把truthy 和falsy 转变
if not name.strip():  # name.strip()是Falsy, 加上not关键字就是 truthy
    print("name is empty")

# 用and 和or 关键字来代替 && 和||
age = 22
if 18 <= age < 65:  # 这个等价于age>=18 and age< 65 也就是说python可以直接写成类似于数学表达式的形式
    print("Eligible")
    
# 三元运算符Ternary，如果true就是前面的，false就是else的
# message = age >= 22 ? 'eligible' : "not" 这个在Python中不合法
age = 22
messag = "Eligible" if age >= 18 else "Not eligible"
print(messag)

循环（两种 for 和while）

# for 循环
for x in "Python":  # 循环string
    print(x)
for y in ["a", "b", "c"]:  # 循环list,一般不用array在python中
    print(y)
for z in range(0, 10):  # 循环number  range(0,5) 返回一个range对象 可用作数字迭代次数
    print(z) # 0123456789
    
#for else
names = ["bin", "Jslng", "dag"]
for name in names:
    if name.startswith("J"):
        print("found")
        break
else:# 当循环都执行完成之后会走else
    print("not found")

#wihle 循环
guess = 0
answer = 4
while answer != guess:
    guess = int(input("Guess: "))

方法def

# 可以给形参parameter设置默认值，在传参的时候就可以不传这个参数 可以设置传入参数类型，并用箭头指定返回值类型
def increment(number: int, by: int = 1) -> tuple:
    # 如果想返回多个值，多个值作为一个整体，这个值放在元组tuple中
    # 元组和列表相似但是是小括号parenthesis
    # 但是元组是不可以改变的read only，有点类似于erlang中的元组定义。
    return (number, number + by) 

print(increment(2,3) # (2,5)
print(increment(2,by=3) # (2,5) 用来标注by的值传入，更readable
print(increment(2))  # 传进的参数argument


## 向方法中传入元组
def multiply(*l):  # 用*加参数来接收tuple
    total = 1
    for number in l: # 用for 来遍历tuple
        total = total * number
    return total


print(multiply(2, 3, 4, 5))# 自动将传入的所有参数package成一个tupple

# 向方法中传入字典
def save_dic(**user):
    print(user)  # {'id': 1, 'name': 'fuck'} 打印字典类似于javascript
    print(user["id"])  # 1


save_dic(id=1, name="fuck")  # 传入键值对

函数在定义中，通过在参数前加星号，将传递进来的多个参数转化为一个对象，元组或字典，可以说是将这些参数值收集起来。
参数前加一个星号，表明将所有的值放在同一个元组中，该参数的返回值是一个元组。
参数前加两个星号，表明将所有的值放在同一个字典中，该参数的返回值是一个字典。

变量作用范围

l = 4  # l是全局变量
k = 3
if True:
    m = 5  # 在if或者for中使用变量算全局变量，外面也可以使用


def greet():
    l = 6  # 在方法中使用的变量是局部变量，
    # 外界不能使用。当方法中创建一个和全局变量相同的变量时，他是一个新的变量而和全局变量l不是同一个
    print("local l :", l)


def ttt():
    global k  # 利用globle关键字拿到全局变量，并使用
    k = 6   # 不要修改全局变量，虽然可以修改，但这很不合理，这里只是做个演示


greet()
ttt()
print("l", l)
print("m", m)
print("k", k)

Data Structure

List

list基础

list中的每个对象可以是不相同的类型

letters = ["a", "b", "c"]  # 一个字符串列表
matrix = [[0, 1], [2, 3]]  # 列表里面嵌套列表
zeros = [0] * 5  # 重复列表的元素，可以得到[0,0,0,0,0]
conmbined = zeros + letters  # 拼接列表
numbers = list(range(20))  # range方法会返回一个可迭代对象，类型是对象，一般用于for循环
# list()函数是对象迭代器吧，把对象转化为列表，返回值是列表
chars = list("HEllo world")

print(len(chars)) # 11
print(conmbined) # [0, 0, 0, 0, 0, 'a', 'b', 'c']
print(numbers) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
print(chars) # ['H', 'E', 'l', 'l', 'o', ' ', 'w', 'o','r', 'l', 'd']

## 剪切list
letters = ["a", "b", "c", "d"]
letters[0] = "A"  # 可以修改list中的变量，而string中则不能修改
print(letters)  # ['A', 'b', 'c', 'd']
print(letters[0:3])  # 剪切list
print(letters[::-1])  # reverse order  ['d', 'c', 'b', 'A']


## 取list中的元素，解包
numbers = [1, 2, 3, 4, 5, 5, 5, 5, 3, 2, 1, 9]
first, *other, last = numbers  # 把list中的元素分别传给first。。这个叫做unpack(解包)
# * 为可变参数列表，也就是表示省略的部分参数列表
print(first, last)  # 1，9
print(other)  # [2, 3, 4, 5, 5, 5, 5, 3, 2, 1]

## list循环取值
letters = ["a", "b", "c"]
for l in letters:
    print(l)
'''
a
b
c
'''
for l in enumerate(letters):
    print(l)
'''可以得到带有序号的tuple
(0, 'a')
(1, 'b')
(2, 'c')
'''
for index, l in enumerate(letters):
    print(index, l)
''' 在for循环时直接解包tuple并分别得到index和l
0 a
1 b
2 c
'''

list增删改查元素

letters = ["a", "b", "c", "d", "b"]
## 添加元素
letters.append("e")  # 在末尾增加
letters.insert(1, "9")
print(letters) # ['a', '9', 'b', 'c', 'd', 'b', 'e']
## 删除元素
letters.pop(1)  # 删除1的位置的元素
print(letters)
letters.remove("b")  # 删除指定元素，只删除第一个，如果要删除所有b则需遍历循环
print(letters)
del letters[0:3] # 删除多个元素，0-3的元素
print(letters)
letters.clear() #清空
print(letters)
## 查找元素
letters = ["a", "b", "c"]
print(letters.count("c"))  # 计算"c"的数量 1
if "c" in letters:
    print(letters.index("c"))  # 找到c的位置

## 元素排序
numbers = [51, 2, 6, 23, 1, 4, 7]
numbers.sort()  # 会修改原数组
print(numbers)
numbers.sort(reverse=True)
print(numbers)
numbers2 = [51, 2, 6, 23, 1, 4, 7]
temp = sorted(numbers2)
print(temp)
temp = sorted(numbers2, reverse=True)  # 生成新list而不修改原list,
# reverse=True相当于传默认值，这在java中是不存在这种方式的
print(temp)


#list为复杂类型，如元组排序
# 一个tuple list
items = [("product1", 1),
         ("product2", 5),
         ("product3", 2)
         ]
items.sort()  # 这不会排序，因为python不知道该如何排序
print(items)

# lambda function 是一行为匿名函数的表达式
lambda x, y: x*y  # 这个匿名函数输入是x和y，返回值是x*y

# sort方法会遍历items的每个item，在这里接收每个Tuple然后返回item【1]也就是数字部分
items.sort(key=lambda item: item[1])
# 这样 sort 排序的就是按照数字部分来进行排序
print(items)

map方法

# 取item中元组中的数字产生一个新list只包含数字
items = [("product1", 1),
         ("product2", 5),
         ("product3", 2)
         ]

prices = []
for item in items:
    prices.append(item[1])
print(prices)  # [1, 5, 2]

# map和lsit方法


def f(x):
    return x*x


y = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# map方法接收两个参数，用于把后一个参数列表中的每个元素分别执行第一个参数f方法并返回一个新的迭代器
print(map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]))  #得到的是一个map也是一个迭代器 
print(list(map(f, y))) # [1, 4, 9, 16, 25, 36, 49, 64, 81] 如果想获得一个新的列表则需要外层添加list方法转化为列表


# 用map方法来实现取元组中的数字并产生新list只包含数字
items = [("product1", 1),
         ("product2", 5),
         ("product3", 2)
         ]
# 取每一个Items中的元素进行
# 取items中的每一个元素来放到第一个参数的匿名方法中执行，返回item[1]的值
prices = list(map(lambda item: item[1], items))
print(prices) # [1,5,2]

filter 方法

items = [("product1", 1),
         ("product2", 5),
         ("product3", 2)
         ]

# filter 是通过生成 True 和 False 组成的迭代器将可迭代对象中不符合条件的元素过滤掉；而 map 返回的则是 True 和 False 组成的迭代器。
prices = list(map(lambda item: item[1], items))
prices1 = list(map(lambda item: item[1] > 1, items))
prices2 = list(filter(lambda item: item[1] > 1, items))

print(prices) # [1, 5, 2]
print(prices1) # [False, True, True]
print(prices2) # [('product2', 5), ('product3', 2)]

list comprehension 列表推导式

# 列表推导式更适合遍历list并执行方法，他可以替代map和filter的功能
# 基本语法为：[expresion for item in items]  返回一个列表
testList = [1, 2, 3, 4]


def mul2(x):
    return x*2


print([mul2(i) for i in testList])  # [2, 4, 6, 8]

# 用 list comprehension来写这个来替代lambda表达式
items = [("product1", 1),
         ("product2", 5),
         ("product3", 2)
         ]


prices = list(map(lambda item: item[1], items))
prices_list = [item[1] for item in items]

prices2 = list(filter(lambda item: item[1] > 1, items))
prices2_list = [item for item in items if item[1] > 1]

print(prices)  # [1, 5, 2]
print(prices_list)  # [1, 5, 2]
print(prices2)  # [('product2', 5), ('product3', 2)]
print(prices2_list)  # [('product2', 5), ('product3', 2)]

zip function

list1 = [1,2,3]
list2 = [10,20,30]
print(list(zip("abc",list1,list2))) # [('a', 1, 10), ('b', 2, 20), ('c', 3, 30)]

队列

from collections import deque
queue = deque([1, 2])
queue.append(3)
queue.append(4)
queue.append(5)
print(queue)
queue.pop()
print(queue)
queue.popleft()
print(queue)

tuple 元组

如果你不想修改一个序列，或者防止这个序列被偶然修改，可以用tuple来代替list

# tuples 基本和list一样但是是read only的
point = 1, 2, 3 # tuple
point1 = (1)
point2 = (1,)
point3 = (1, 2)+(3, 4) # (1, 2, 3, 4)
point4 = tuple([5, 6])  # (1, 2, 3, 4)把list转化为 tuple
point5 = tuple("helllo") # ('h', 'e', 'l', 'l', 'l', 'o')
print(type(point))  # tuple
print(type(point1))  # int
print(type(point2))  # tuple
print(point[0]) # 1

交换变量

利用tuple 交换变量

x = 1
y = 2
a,b = 2,1 # a=2, b=1 unpack tuple
x, y = y, x  # x,y = (2,1) 然后unpack tuple分别赋值给x,y
print("x=", x)  # 2
print("y=", y)  # 1

当需要处理大量的数据的时候用array，其他情况下用list或者tuple

set

集合，里面不能有重复元素，无序，不重复集合

numbers = [1, 1, 2, 4, 6, 7, 8]
first = set(numbers)
print(first)  # {1, 2, 4, 6, 7, 8} 大括号表示并且会删除相同元素,无序不重复集合
second = {1, 4}
second.add(5)
second.remove(5)
print(first & second)  # 交集 {1, 4}
print(first | second)  # 并集 {1, 2, 4, 6, 7, 8}
print(first - second)  # 差集 {8, 2, 6, 7}

if 1 in first:  # set中的元素无法通过index获取到
    print("yes")

dictionary 字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割,格式如下所示：

d = {key1 : value1, key2 : value2 }

key一般是唯一的，如果重复最后的一个key值对会替换前面的，value不需要唯一。格式类似于json字符串，key和value都要用冒号

# value可以取任何数据类型，但key必须是不可变的元素，如字符串，数字或元组。
dict1 = {'abc': 123, 98.6: 37, 'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print(dict1)
dict2 = dict(b=3, y=4)  # 用这种方法来创建，key就只能是字符串
print(dict2)
# 访问value:用[key] 或get方法
print("dict['Name']: ", dict1['Name'])  # dict['Name']:  Zara
print(dict1.get('a'), dict1.get('Name'))  # None Zara,如果没有则返回None
# no word 可以指定不存在的时候的返回值，如果不存在则返回指定值，如果存在则返回正确值
print(dict1.get('a', 'no word'))

# 查看key是否存在
char_seq = {'a': 1, 'b': 2}
char = 'a'
if char in char_seq:
    print("yes")
else:
    print("no")

# 循环dictionary，每次循环拿到key
for key in dict1:
    print(key, dict1[key]) # 输出在下
'''
abc 123
98.6 37
Name Zara
Age 7
Class First
'''
# 另一种方法，
for key,value in dict1.items(): # 每次得到一个tuple然后，unpack 
    print(key,value) # 输出同上


# 修改，重新赋值、
dict1['Name'] = 'binbin'
print("dict['Name']: ", dict1['Name'])
# 删除
del dict1['Name']  # 删除键是'Name'的条目
dict1.clear()      # 清空词典所有条目
del dict1         # 删除词典

comprehension

# comprehension
# [expression for item in items] 遍历每个元素然后执行expression

# list comprehension
values = []
for x in range(5):
    values.append(x*2)
print(values)

values2 = [x*2 for x in range(5)]  # 这个与上面的代码效果相同
print(values2)  # [0, 2, 4, 6, 8]

# set comprehension
values3 = {x*2 for x in range(5)}
print(values3)  # {0, 2, 4, 6, 8}

# dictionary comprehension
values = {}
for x in range(5):
    values[x] = x*2
print(values) # {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}
# 以下代码与上面功能相同
values2 = {x: x*2 for x in range(5)}
print(values2) # {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

# tuple comprehension
from sys import getsizeof
# tuple comprehension 也叫generator expression
values = (x*2 for x in range(100000))
print(values)  # 这里得到的是一个generator而不是tuple
print(getsizeof(values))  # 120
for x in values:  # generator is iterable
    pass
    # print(x)

# 如果存储在列表里占用空间非常大
values2 = [x*2 for x in range(100000)]
print(getsizeof(values2))  # 824464

unpack operator 解包操作符

python中用*号，而javascript中用... 作为解包操作符

# unpack operator
numbers = [1, 2, 3]
print(numbers)  # [1,2,3]
print(*numbers)  # 1 2 3 unpack

values = list(range(5))
print(values)  # [0, 1, 2, 3, 4]
print(*range(5))  # 0 1 2 3 4   任何iterable的组合都可以unpack


values2 = [*range(5), *"hello"]
print(values2)  # [0, 1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o']

first = [1, 2]
second = [3, 4]
values3 = [*first, "a", *second] # 解包后重新组合放到一个list中
print(values3)  # [1, 2, 'a', 3, 4]

# unpack dictionary 用双**
firstd = {'x': 1}
secondd = {'x': 10, 'y': 20}
combined = {**firstd, **secondd, 'z': 30}
print(combined)  # {'x': 10, 'y': 20, 'z': 30}

exersice

sorted对字典值排序
介绍一个练习，把一个字符串，找出出现次数最多的字母。

from pprint import pprint
sentences = "This is a common interview question."
char_sequence = {}


def store_character(char):
    if char in char_sequence:
        char_sequence[char] += 1
    else:
        char_sequence[char] = 1


{store_character(char) for char in sentences}
pprint(char_sequence, width=1)
# sorted(iterable,key,reverse)，sorted一共有iterable,key,reverse这三个参数。
char_sequence_sorted = sorted(char_sequence.items(),
                              key=lambda item: item[1],
                              reverse=True)
pprint(char_sequence_sorted[0])

异常exception

try:
    file = open("app.py")
    age = int(input("age:"))
    x = 10/age
except (ValueError, ZeroDivisionError) as ex:  # 可以写多种异常
    print("You did not enter a valid type")
    print(ex)
    print(type(ex))
else:  # 没有异常的时候执行
    print("no exception")
finally:  # 无论有没有异常都会执行
    file.close()

# 由于finally 太冗长，可以用with语句了来替代,就不 需要写finally和close了，with会自动关闭文件
try:
    with open("app.py") as file:
        print("file opend")
        data = file.read()
# 同上
'''
age:a
You did not enter a valid type
invalid literal for int() with base 10: 'a'

'''

Class 类

类的命名用每个首字母大写，而变量和方法的命名用小写加下划线

class Point:  # 创建类
    def draw(self):  # 类中的方法至少要有一个parameter
        print("draw")


point = Point()  # 创建对象，跟调用方法一样调用这个类
point.draw()  # 调用对象中的方法
print(type(point))  #  类型为Point
print(isinstance(point, Point))  # True 是否是他的对象

类变量和私有变量

class Point:  
    defautl_color = "a"  # 属于类中的变量，可以用类直接访问

    def __init__(self, x, y):  # 此为构造方法
        self.x = x  # 在构造方法中创建成员变量 instance attribute，并赋值
        self.y = y # y为成员变量
		self.__z = 2 # z此为私有变量，只在内部使用
		
point = Point(1, 2)  # 创建对象并初始化成员变量
print(point.x, point.y)  # 调用成员变量
point.z = 3  # 由于python是动态的，所以不必在初始化时候赋值，也可以在之后动态赋值， 但是不能访问point.__z
print(point.z)
print(Point.defautl_color)
print(point.defautl_color)

类中的方法

class Point:

    def __init__(self, x, y):  # 此为构造方法，前后带下划线的方法都会自动执行不需要调用叫做magic method
        self.x = x  # 在构造方法中创建成员变量 instance attribute，并赋值
        self.y = y

    @classmethod  # 用来表明是类方法
    def zero(cls):  # 类方法中默认为cls为parameter
        return cls(0, 0)  # 给变量初始化，相当于Point(0,0),创建类的时候赋值

   

    def draw(self):  # instance method
        print(f"point ({self.x},{self.y})")


point = Point.zero()  # 直接调用这个方法来创建这个类并初始化
point.draw()

magic method

class Point:

    def __init__(self, x, y):  # 此为构造方法
        self.x = x
        self.y = y

    def __str__(self):  # 为magic 方法也就是继承的方法 控制print的属性，重写该方法
        return f"({self.x}, {self.y})"

    def __eq__(self, other):  # 重写比较方法，self为本身对象，other为其他对象
        return self.x == other.x and self.y == other.y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)


point = Point(1, 2)
objjj = Point(1, 2)
print(point == objjj)  # Ture 如果不重写__eq__方法，则不相等，重写之后相等
point2 = Point(1, 2)
print(point2)  # (1,2) 会调用_str_方法
point3 = Point(2, 2)
print(point3+point2) # (3, 4) 调用重写的__add__方法

inheritance 继承

继承尽量用一级，不要超过两级，那样会造成继承滥用很多问题。

class Animal:
    def __init__(self):
        self.age = 1

    def eat(self):
        print('eat')


# Animal is parent
class Mammal(Animal):
    def walk(self):
        print('walk')


m = Mammal()
m.eat() # 子类对象继承父类对象
print(m.age) # 子类也会继承父类的成员变量
print(isinstance(m,Animal)) # True 子类对象属于父类
print(issubclass(Mammal,Animal)) # True 查看是否是子类

重写方法

class Animal:
    def __init__(self):
        print("Animal constructor")
        self.age = 1

    def eat(self):
        print('eat')


# Animal is parent
class Mammal(Animal):
    def __init__(self):  # 当子类有构造方法的时候就相当于重写父类的构造方法，父类构造方法不会被执行,所以就不会继承到父类的age成员变量
        print("Mammal constructor")
        self.weight = 2
        # 如果想继承则在这里需添加super方法
        super().__init__()

    def walk(self):
        print('walk')


m = Mammal()
print(m.weight)
print(m.age)
"""
Mammal constructor
Animal constructor
2
1
"""

# 如果父类中包含抽象方法，则子类必须重写抽象方法
from abc import ABC, abstractmethod
class Stream(ABC):
    @abstractmethod
    def read(self):
        pass

class MemoryStream(Stream):
    def read(self):
        print("memory read")

m = MemoryStream()
m.read()

polymorhism 多态

polymorhism = many forms

from abc import ABC, abstractmethod


class UIControl(ABC):
    @abstractmethod
    def draw(self):
        pass


class TextBox(UIControl):
    def draw(self):
        print("textbox")


class DropDownList(UIControl):
    def draw(self):
        print("dropdownList")

# draw function并不知道传来的是什么，这些都由传过来的东西决定
def draw(controls):
    for control in controls:
        control.draw()


ddl = DropDownList()
textBox = TextBox()

draw([textBox,ddl])

因为python是动态语言，所以可以写成

class TextBox:
    def draw(self):
        print("textbox")


class DropDownList:
    def draw(self):
        print("dropdownList")

# draw function并不知道传来的是什么，这些都由传过来的东西决定
def draw(controls):
    for control in controls:
        control.draw()


ddl = DropDownList()
textBox = TextBox()

draw([textBox, ddl])

Module

从哪个文件开始执行代码，则这个文件就为main 文件
当两个文件在同一文件夹下

# sales.py
def calc_tax():
    print("tax")


def calc_shipping():
    print("ship")

# test.py
# 第一种方法导入整个文件作为一个对象，会首先查找当前路径文件夹下的文件，然后再查找python安装包路径下安装文件
import sales

# 第二种导入方法：从sales.py文件中导入指定方法
from sales import calc_shipping, calc_tax


# 第一种
sales.calc_shipping()

# 第二种
calc_shipping()  # 调用其他文件中的方法
calc_tax()

使用绝对路径导入包,sales为当前目录commer文件夹，customer文件夹下的文件

# 从customer这个package导入sales.py作为对象,选用绝对路径,也可以使用相对路径
from commers.customer import sales


sales.calc_shipping() # ship
print(sales.__file__) # /Users/chongbin/Desktop/project/python_project/python_study/commers/customer/sales.py
print(sales.__name__) # commers.customer.sales
print(sales.__package__) # commers.customer

Python standard library

python可以压缩和解压缩zip文件，具体在这里不做详细介绍。

work with CSV file

import csv

# 写csv文件
with open("data.csv", "w") as file:
        writer = csv.writer(file)
        writer.writerow(["t_id", "p_id", "s_id"])
        writer.writerow([122, 4, 5])
        writer.writerow([132, 3, 53])

import csv

# 读csv文件
with open("data.csv", ) as file:
        reader = csv.reader(file)
        # print(list(reader))
        for row in reader:
            print(row)

work with json files

写json文件
python中的字典格式和json字符串格式一样

import json
from pathlib import Path

movies = [
    {"id": 1, "title": "terminater", "year": 1984},
    {"id": 2, "title": "kingdergaredg", "year": 1990},
]

data = json.dumps(movies) # 把字典数组转化成json

print(data)# [{"id": 1, "title": "terminater", "year": 1984}, {"id": 2, "title": "kingdergaredg", "year": 1990}]

Path("movies.json").write_text(data) # 在指定路径写json文件

movies.json文件

[{"id": 1, "title": "terminater", "year": 1984}, {"id": 2, "title": "kingdergaredg", "year": 1990}]

读取json文件

import json
from pathlib import Path


data = Path("movies.json").read_text() # 读取json文件
movies = json.loads(data) # 把json字符串转为字典数组
print(movies) #[{'id': 1, 'title': 'terminater', 'year': 1984}, {'id': 2, 'title': 'kingdergaredg', 'year': 1990}]

还有python读取数据到sqlite数据库或者mongodb数据库，这里不做详细介绍

work with time

计算消耗时间

import time


def timeConsuming():
    for i in range(5000000):
        pass


start = time.time()
timeConsuming()
end = time.time()
duration = end - start
print(duration) # 0.12488579750061035 秒

date对象

from datetime import datetime
import time

dt = datetime.fromtimestamp(time.time()) # 把timestamp转化为date对象
print(dt) # 2019-02-10 22:10:14.704558
dt1= datetime(2018,1,2) # 初始化date对象
print(dt1) # 2018-01-02 00:00:00
dt2 = datetime.now() # 得到当前时间 date 对象
print(dt2) # 2019-02-10 22:11:43.860392
dt3 = datetime.strptime("2019/02/03","%Y/%m/%d") #把字符串转化为date对象
print(dt3) # 2019-02-03 00:00:00
print(dt3.strftime("%Y/%m")) #2019/02 把date对象转化为字符串

计算相差天数timedelta

from datetime import datetime, timedelta


dt1 = datetime.now()
dt2 = datetime(2019,8,5)

duration = dt2 - dt1
print(duration) #175 days, 1:42:10.830655
print("duration days", duration.days) # duration days 175

dt3 = datetime(2019,8,5) + timedelta(days=1)
print(dt3) # 2019-08-06 00:00:00

random value 生成随机数

import random
import string

print(random.random()) # 生成0，1之间随机数
print(random.randint(1,10)) # 生成1，10之间一个数 包含1，10
print(random.choice([1,2,3,4])) # 生成1234之间一个数
print(random.choices([1,2,3,4],k=2)) # 生成1234之间两个数
print(random.choices("askdjhgliuasihasjdf",k=4)) #['d', 'a', 'l', 'h'] 
print("".join(random.choices("askdjhgliuasihasjdf",k=4))) #hjdg 可以作为生成密码功能
print("".join(random.choices(string.digits + string.ascii_letters,k=4))) #hjdg 可以作为生成密码功能

numbers = [1,2,3,4]
random.shuffle(numbers) #将数组洗牌
print(numbers) # [1, 4, 2, 3]

打开浏览器

import webbrowser

webbrowser.open("http://google.com")

调用外部程序

import subprocess

subprocess.run("ls") # 相当于在terminal执行ls命令在当前文件夹
subprocess.run(["/anaconda2/envs/py3-7anconda/bin/python","/Users/chongbin/Desktop/project/python_project/python_study/timeDelta.py"]) # 通过这个命令执行另一个pyhone文件

Python package index

pypi 类似于npm的包管理工具他的运行命令是pip，来安装或者卸载包
pip都是附着在python版本中的，所以在每个不同的python版本中，有单独的pip
pip -V 查看版本
pip install --upgrade pip 更新
pip list 查看已安装的包
pip install xx 安装某个包

Popular Python package

Yelp

yelp 作为一个http endpoint的库可以模拟endpoint，然后可以通过http方法来连接endpoint。

操作PDF

pip install pypdf2

import PyPDF2

merger = PyPDF2.PdfFileMerger()
file_names = ["CV.pdf","CV 2.pdf"]
for file_name in file_names:
    merger.append(file_name)
merger.write("combined.pdf")

操作excel

pip install openpyxl

import openpyxl

wb = openpyxl.load_workbook("Bill.xlsx")
print(wb.sheetnames) #['2019', '杂物', '购物']  打印sheet名称

wb.create_sheet("testSheet",3) # 创建一个sheet
print(wb.sheetnames) #['2019', '杂物', '购物', 'testSheet']

sheet0 = wb["2019"] # 获得sheet对象
cell = sheet0["b2"] #   获得某个cell对象
print(cell.value) # 超市6.9
print(cell.row) # 2
print(cell.column) # 2
print(cell.coordinate) # B2

print(sheet0.max_row) # 42
print(sheet0.max_column) # 6

numpy

import numpy as np 

array = np.array([1,2,3])
print(array) # [1 2 3] 这是一个numpy array
print(type(array)) # 

array2 = np.array([[1,2,3],[4,5,6]]) # matrix矩阵
print(array2) 
'''
[[1 2 3]
 [4 5 6]]
'''
print(array2.shape) # (2,3) 表示2行三列

array3 = np.zeros((3,4),dtype=int)
print(array3)
'''
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]
'''
array4 = np.full((3,4),9,dtype=int)
print(array4)
'''
[[9 9 9 9]
 [9 9 9 9]
 [9 9 9 9]]
'''
array5 = np.random.random((3,4))
print(array5)
'''
[[0.76363434 0.91464726 0.26182753 0.3233505 ]
 [0.97151014 0.41479824 0.17803116 0.69085061]
 [0.81831059 0.60364471 0.54871925 0.47334383]]
'''
print(array5[0,0]) # 0.76363434
print(np.sum(array5)) # 计算和

first = np.array([1,2,3])
second = np.array([4,5,6])
print(first + second) # [5 7 9]

Python with machine learning

几个做machine learning 流行的库
Numpy： 提供大规模数组矩阵
Pandas：提供dataframe做数据处理，dataframe类似于矩阵也就是excel表格
MatPlotLidb：提供画图功能
Scikit-Learning: 提供做机器学习的一些算法

jupyter

做machine learning用Jupyter来做更方便而且直观。可以一行一行的执行代码，而如果用类似VSCODE则每次都要执行会十分麻烦，而且在控制台打印很不直观。
从anaconda里启动jupyter，这时会在浏览器自动打开，jupyter notebook，在指定路径下创建新的notebook。
界面展示：

使用说明：
jupyter有两种状态，绿色编辑状态，蓝色选择状态
点击run按钮每次只会运行所选择的篮框里的In。如果想全部运行代码，需要选择cell->run all
找到insert 按钮插入cell
双击d删除一个cell
shift+tab查看方法说明
利用kaggle网站可以下载想要的数据集data set。

pandas操作数据

import pandas as pd
pd.read_csv('vgsales.csv')#读取csv文件并展示
#out
df = pd.read_csv('vgsales.csv') # 把文件作为dataframe对象
df.shape # 统计row 和column的数量
#out
df.describe()# 可以表示column的数量以及一些信息
#out
df.values # 把df转化成array
#out

问题集锦

matplotlib 在vscode无法画图报错解决方法

导入时候需添加TkAgg

import matplotlib
matplotlib.use("TkAgg")
from matplotlib import pyplot as plt
from matplotlib import lines


plt.show()