python基础之——语法(from 莫烦python)

1.print

字符串不可以直接和数字相加
print(float(‘1.2’)+3) #float()是浮点型，可以把字符串转换成小数
print(int(‘2’)+3) #int为定义整数型
print(int(1.9)) #当int一个浮点型数时，int会保留整数部分

2.基础数学运算

在python中，^用两个**表示，如3的平方为3**2 , **3表示立方，**4表示4次方，依次类推

3.变量

可以将一个数值，或者字符串串附值给自变量，如apple=1，apple=‘iphone7 plus’
需要加下划线，如apple_2016=‘iphone 7 plus’
一次定义多个自变量 a,b,c=1,2,3

4.循环

while condition:
expressions
要停止程序，使用 ctrl + c 终止程序。
整数和浮点数也能进行 Boolean 数据操作, 具体规则，如果该值等于 0 或者 0.0 将会返回 False 其余的返回 True；数据类型 None, 将会返回 False。
在 Python 中集合类型有 list、 tuple 、dict 和 set 等，如果该集合对象作为 while 判断语句， 如果集合中的元素数量为 0，那么将会返回 False, 否则返回 True，比如：
a = range(10) #range() 函数可创建一个整数列表
while a: #判断是否为空
print(a[-1]) #打印最后一个内容
a = a[:len(a)-1] #切片操作去掉最后一个元素
#打印 9 8 7 6 5 4 3 2 1 0
语法：range(start, stop[, step])
start默认0，step默认1，range(5)等价于range(0,5)等价于range(0,5,1)

5.判断

if condition:
expressions
判断条件： x < y < z，（相当于 x < y and y < z）但不鼓励这种风格

if condition:
true_expressions
else:
false_expressions
python 可以通过 if-else 的行内表达式完成类似三目运算符的功能。
var = var1 if condition else var2 #如果条件为true,var=var1否则var=var2

#一旦某个条件为 True，那么将执行对应的 expression。 并在之代码执行完毕后跳出该 if-elif-else 语句块，往下执行,与c中类似
if condition1:
true1_expressions
elif condition2:
true2_expressions
elif condtion3:
true3_expressions
elif …
…
else:
else_expressions

6.def函数

def function_name(parameters):
expressions #可用return返回
#上述两行代码只定义了函数并未执行函数，在命令提示符中输入function_name(参数)，会执行函数。若在脚本中调用脚本，在脚本最后添加function_name()

7.函数默认参数

def function_name(para_1,…,para_n=defau_n,…, para_m=defau_m):
expressions
函数声明只需要在需要默认参数的地方用 = 号给定即可, 但是要注意所有的默认参数都不能出现在非默认参数的前面。当然也可以在函数调用过程中传入特定的参数用来修改默认参数。通过默认参数可以减轻我们函数调用的复杂度。
函数自调用:
如果想要在执行脚本的时候执行一些代码，比如单元测试，可以在脚本最后加上单元测试 代码，当该脚本作为一个模块对外提供功能的时候单元测试代码也会执行，这些往往我们不想要的，我们可以把这些代码放入脚本最后：
if __name__ == '__main__':
#code_here
如果执行该脚本的时候，该 if 判断语句将会是 True,那么内部的代码将会执行。 如果外部调用该脚本，if 判断语句则为 False,内部代码将不会执行。

可变参数 （1个，2个到任意个）
#* 修饰，表明该参数是一个可变参数，这是一个可迭代的对象
def report(name, *grades):
total_grade = 0
for grade in grades:
total_grade += grade
print(name, 'total grade is ', total_grade)
注意可变参数在函数定义不能出现在特定参数和默认参数前面，因为可变参数会吞噬掉这些参数（和c++很像，就是可变参数放在形参最右面）

关键字参数
关键字参数可以传入0个或者任意个含参数名的参数，这些参数名在函数定义中并没有出现，这些参数在函数内部自动封装成一个字典(dict).
#使用了 ** 修饰。表明该参数是关键字参数，通常来讲关键字参数是放在函数参数列表的最后
def portrait(name, **kw):
print(‘name is’, name)
for k,v in kw.items():
print(k, v)
如果调用参数 portrait(‘Mike’, age=24, country=‘China’, education=‘bachelor’) 输出:
name is Mike
age 24
country China
education bachelor
通过可变参数和关键字参数，任何函数都可以用 universal_func(*args, **kw) 表达

8.全局&局部变量

在外部定义一个全局变量 a=None, 然后再 fun() 中声明 这个 a 是来自外部的 a. 声明方式就是 global a. 然后对这个外部的 a 修改后, 修改的效果会被施加到外部的 a 上.
APPLY = 100 # 全局变量
a = None
def fun():
global a # 使用之前在全局里定义的 a
a = 20 # 现在的 a 是全局变量了
return a+100

print(APPLE) # 100
print(‘a past:’, a) # None
fun()
print(‘a now:’, a) # 20

9.模块安装

#Numpy 和 matplotlib 都是外部模块, 需要安装以后才会有的.
import numpy as np
import matplotlib.pyplot as plt
更新外部模块 -U的意思是update
$ pip install -U numpy # 这是 python2+ 版本的用法
$ pip3 install -U numpy # 这是 python3+ 版本的用法

10.文件读取

text=‘This is my first test\n ’ #\n换行 \t tab对齐
my_file=open(‘my file.txt’,‘w’) #用法: open(‘文件名’,‘形式’), 其中形式有’w’:write;‘r’:read. ‘a’:append 以增加内容的形式打开
my_file.write(text) #该语句会写入先前定义好的 text
my_file.close() #关闭文件
按行读取：
file= open(‘my file.txt’,‘r’)
content=file.readline() # 读取第一行
print(content)

读取所有行，将每一行的结果存在list中
file= open(‘my file.txt’,‘r’)
content=file.readlines() # python_list 形式
print(content）#输出[‘This is my first test.\n’, ‘This is the second line.\n’, ‘This the third line.\n’, ‘This is appended file.’]
#或者for迭代输出
for item in content:
print(item)
输出:This is my first test.

This is the second line.

This the third line.

This is appended file

11.class类

class Calculator: #首字母要大写，冒号不能缺
name=‘Good Calculator’ #该行为class的属性
price=18
def add(self,x,y):
print(self.name)
result = x + y
print(result)
def minus(self,x,y):
result=x-y
print(result)
调用：

cal=Calculator() #注意这里运行class的时候要加"()",否则调用下面函数的时候会出现错误,导致无法调用.
cal.name
‘Good Calculator’

cal.price
18

class类init功能
class Calculator:
name=‘good calculator’
price=18
def init(self,name,price,height,width,weight): # 注意，这里的下划线是双下划线
self.name=name
self.price=price
self.h=height
self.wi=width
self.we=weight
运行：

c=Calculator(‘bad calculator’,18,17,16,15)
c.name
‘bad calculator’

设置属性的默认值
def init(self,name,price,height=10,width=14,weight=16)

c=Calculator(‘bad calculator’,18)
c.h
10

12.input输入

#variable=input() 表示运行后，可以在屏幕中输入一个数字，该数字会赋值给自变量。
a_input=input(‘please input a number:’)
print(‘this number is:’,a_input)

‘’’’
please input a number:12 #12 是我在硬盘中输入的数字
this number is: 12
‘’’’
input应用在if语句中
a_input=int(input(‘please input a number:’))#注意这里要定义一个整数型
if a_input==1:
print(‘This is a good one’)
elif a_input>=2:
print(‘See you next time’)
else:
print(‘Good luck’)

13.元组

13.1 tuple(cpp11也有tuple)
#用小括号、或者无括号来表述，是一连串有顺序的数字。
a_tuple = (12, 3, 5, 15 , 6)
another_tuple = 12, 3, 5, 15 , 6
for content in a_list:
print(content)
13.2
#list是以中括号来命名的:
a_list = [12, 3, 67, 7, 82]
for content_tuple in a_tuple:
print(content_tuple)

依次输出a_tuple和a_list中的各个元素：
for index in range(len(a_list)):
print("index = ", index, “, number in list = “, a_list[index])
“””
index = 0 , number in list = 12
index = 1 , number in list = 3
index = 2 , number in list = 67
index = 3 , number in list = 7
index = 4 , number in list = 82
“””

for index in range(len(a_tuple)):
print("index = ", index, “, number in tuple = “, a_tuple[index])
“””
index = 0 , number in tuple = 12
index = 1 , number in tuple = 3
index = 2 , number in tuple = 5
index = 3 , number in tuple = 15
index = 4 , number in tuple = 6
“””

list添加：
a = [1,2,3,4,1,1,-1]
a.append(0) # 在a的最后面追加
a.insert(1,0) # 在位置1处添加0
print(a)
#[1, 0，2, 3, 4, 1, 1, -1, 0]
a.remove(2) # 删除列表中第一个出现的值为2的项
print(a[0]) # 显示列表a的第0位的值
print(a[-1]) # 显示列表a的最末位的值
print(a[0:3]) # 显示列表a的从第0位 到 第2位(第3位之前) 的所有项的值
print(a[5:]) # 显示列表a的第5位及以后的所有项的值
print(a[-3:]) # 显示列表a的倒数第3位及以后的所有项的值

a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 显示列表a中第一次出现的值为2的项的索引
print(a.count(-1)) #统计列表中某值出现的次数
a.sort() # 默认从小到大排序
a.sort(reverse=True) # 从大到小排序

14.多维列表

一个一维的List是线性的List，多维List是一个平面的List，可以2维及更多的维度。
a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
[2,3,4],
[3,4,5]] # 三行三列
print(multi_dim_a[0][1])

15.dictionary字典

List是有顺序地输出输入的话，那么字典的存档形式则是无需顺序的。
在字典中，有key和 value两种元素，每一个key对应一个value, key是名字, value是内容。数字和字符串都可以当做key或者value， 在同一个字典中, 并不需要所有的key或value有相同的形式。 这样说, List 可以说是一种key为有序数列的字典。
a_list = [1,2,3,4,5,6,7,8]

d1 = {‘apple’:1, ‘pear’:2, ‘orange’:3}
d2 = {1:‘a’, 2:‘b’, 3:‘c’}
d3 = {1:‘a’, ‘b’:2, ‘c’:3}

print(d1[‘apple’]) # 1
print(a_list[0]) # 1

del d1[‘pear’]
print(d1) # {‘orange’: 3, ‘apple’: 1}

d1[‘b’] = 20
print(d1) # {‘orange’: 3, ‘b’: 20, ‘pear’: 2, ‘apple’: 1}说明字典是无序的
字典还可以以更多样的形式出现，例如字典的元素可以是一个List，或者再是一个列表，再或者是一个function。索引需要的项目时，只需要正确指定对应的key就可以了
def func():
return 0

d4 = {‘apple’:[1,2,3], ‘pear’:{1:3, 3:‘a’}, ‘orange’:func}
print(d4[‘pear’][3]) # a

16.import

import time
print(time.localtime()) #这样就可以print 当地时间了

import time as t
print(t.localtime()) # 需要加t.前缀来引出功能

from time import time, localtime #只import自己想要的功能.
print(localtime())
print(time())

from time import * # 输入模块的所有功能

• import自建的模块
  #自建的模块为 balance.py,保存在默认文件夹
  import balance

17.continue & break

18.try错误处理

try:
file=open(‘eeee.txt’,‘r’) #会报错的代码
except Exception as e: # 将报错存储在 e 中
response = input(‘do you want to create a new file:’)
if response==‘y’:
file=open(‘eeee.txt’,‘w’)
else:
pass
else:
file.write(‘ssss’)
file.close()

19. zip lambda map

zip函数接受任意多个（包括0个和1个）序列作为参数，合并后返回一个tuple列表,：
a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab)) #需要加list来可视化这个功能
“”"
[(1, 4), (2, 5), (3, 6)]
“”"
for i,j in zip(a,b):
print(i/2,j*2)
“”"
0.5 8
1.0 10
1.5 12
“”"

lambda实现简化代码的功能
fun= lambda x,y:x+y
x=int(input(‘x=’)) #这里要定义int整数，否则会默认为字符串
y=int(input(‘y=’))
print(fun(x,y))

“”"
x=6
y=6
12
“”"

map把函数和参数绑定在一起

def fun(x,y):
return (x+y)

list(map(fun,[1],[2]))
“”"
[3]
“”"

list(map(fun,[1,2],[3,4]))
“”"
[4,6] #[1+3,2+4]
“”"

20.浅拷贝 深拷贝

一个对象的id值在CPython解释器里就代表它在内存中的`地址

import copy
a=[1,2,3]
b=a #深拷贝，
id(a)==id(b) #附值后，两者的id相同，为true。
True

b[0]=222222 #此时，改变b的第一个值，也会导致a值改变。
print(a,b)
[222222, 2, 3] [222222, 2, 3] #a,b值同时改变

浅拷贝.copy()：只是拷贝了最【外围】的对象本身，【内部的元素】都只是拷贝了一个引用而已

import copy
a=[1,2,3]
c=copy.copy(a) #拷贝了a的外围对象本身,浅拷贝
print(id(a)==id©) #id 改变 为false
False

c[1]=22222 #此时，我去改变c的第二个值时，a不会被改变。
print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不变,c的第二个值变了，这就是copy和‘==’的不同

深拷贝.deepcopy()，对【外围和内部元素】都进行了拷贝对象本身，而不是对象的引用。所以原来的对象与拷贝后是两回事。

e=copy.deepcopy(a) #e为深拷贝了a
a[2][0]=333 #改变a中内部元素列表第一个的值
e
[1, 2, [3333, 4]] #因为是深拷贝，这时e中内部元素[]列表的值不会因为a中的值改变而改变

21.多线程threading

import threading

def thread_job():
print(‘T1 start’)
for i in range(10):
time.sleep(0.1)
print(‘T1 finish\n’)

def t2_job():
print(‘T2 start’)
print(‘T2 finish\n’)

def main():
added_thread=threading.Thread(target=thread_job,name=‘T’) #添加线程及其工作、名字
thread2=threading.Thread(target=t2_job,name=‘T2’)
added_thread.start() #运行线程
added_thread.join()
print(‘all done’)
#print(threading.active_count()) #当前激活的线程数目
#print(threading.enumerate()) #当前激活的线程名称
#print(threading.current_thread())#当前正在运行的程序 的线程

if name==‘main’

输出结果(不加join时)：T1 start
all done

过了一会 T1 finish

加join时：T1 start
T1 finish
all done
join作用：等线程运行完成后才运行后面的语句

added_thread.start()
t2.start()
t2.join()
打印：t1 start
t2 start

      t2 finish

      all done
     
      t1.finish

added_thread.start()
t2.start()
t1.join()
t2.join()
打印：
t1 start
t2 start

      t2 finish

      t1.finish

      all done

多线程无法返回，可以把结果放进一个queue
GIL不一定有效率，在不停地切换线程，读写的时间可以运行下一个线程，时间少一点点
加锁lock= threading.lock()
lock.acquire()
// 操作
lock.release()

22.多进程multiprocessing

import multiprocessing as mp
#与创建线程类似

多进程必须在main下调用
if name==‘main’
q=mp.Queue() #q.get()一次会少一次
p1=mp.multiprocessing(target=t2_job,args=(q,)) #注意这里job没括号，是引用，不是调用;args只有一个参数时后面要加，说明它是一个可以迭代的东西
p1.start()
p1.join()

用queue存储多进程的运算结果，job与多进程同样不能有return ,将queue作为参数传入job函数

进程池pool里面job函数可以return
pool=mp.Pool(process=2)# 指定cpu核数为2，空参默认全部核数
res=pool.map(job,range(10))#将job返回值绑定到res，自己分进程
print res
pool.apply_asyc(job,(i,)) for i in range(10) #一次只会把任务推给一个进程

23.Tkinter

Tkinter 是使用 python 进行窗口视窗设计的模块.

import tkinter as tk

window=tk.Tk()
window.title(’ xxx’)
window.geometry(‘200x100’)

24.pickle

pickle 是一个 python 中, 压缩/保存/提取 文件的模块. 最一般的使用方式非常简单. 比如下面就是压缩并保存一个字典的方式. 字典和列表都是能被保存的.

—>待续