欢迎大家来到511python学习课程

表达式	运算结果	说明
9 + 4	13	加法
9 - 4	5	减法
9 * 4	36	乘法
9 / 4	2.25	数学除法
9 // 4	2	取整除法
9 % 4	1	取余（模运算）
2**10	1024	乘方，2的10次方
36**0.5	6	乘方运算的特例：平方根
7+9**0.5	10.0	乘方的优先级高
(7+9)**0.5	4.0	括号改变优先级

文章摘要：关于怎么学习python这件事我们展开了深度学习，并在下面总结出了部分代码，仅供参考

python基础知识+ 运用

1. 使用缩进完成语法对齐功能
2. def Hello():

print("hello")

for i in range(10):

print("i = %d" %i)

1. 程序的注释

采用 # 进行单行注释，采用‘’‘ This is comment''' 来完成多行注释。（Remark: 在pycharm中可以采用 ctrl + / 完成对程序的注释，同时对于已经注释的程序，则再次 ctrl+/ 可以取消注释）''' 多行注释'''

1. 命名法则

python对程序中的小写敏感。

3.1 变量名：一般采用驼峰命名法。首字母小写，后面的单词首字母大写，例如 "printFunction"

3.2 类名建议首字母大写

3.3 Python中33个保留字，不能重名：def , class, if , for , while, not , and , pass 等

1. python中的变量属性

5.1. python中变量可以直接进行赋值 (str int float bool type(valueName)) True False

(C++ true false)

a_float = 1.2

print(type(a_float))

b_str = "hello"

print(type(b_str))

print(type(person))

a_int = 1

print(type(a_int))

5.2. 不同数据类型可以默认转换 强制类型转换 str(valueName) int(a_str) float(a_float)

print(a_int + a_float)

print(str(a_int + a_float) + a_str)

5.3. python中含有bool型数据类型，即 True, False 判断语句中，True 非零值， False

if (a)

1. python中的标准输入输出
   1. print("hello") 默认含有换行回车操作，若要取消换行，需要print("hello", end="")
   2. print("a = %f \t b=%f" %(a,b))
   3. print(f"a = {a}, b={b}")
   4. name = input()
   5. print("hello"+"\t"+name)

注：输入的一定是字符串

python程序编程

顺序，分支，循环三种程序结构

1. 1. 1. 在C语音的程序编写中，程序的入口为
      2. int main(int argc, char** argv)
      3. {
      4. /*
      5. main program to be programmed
      6. */
      7.     return 1;

}

python采用脚本式编程，程序自上而下顺序执行。遇到函数以及类时，跳过不执行。一般我们采用如下语句申明main函数

1. 1. 1. 程序的执行方式：顺序，分支，循环，下面分别予以介绍

1. 1. 1. 分支程序， 包含有 if else, 注：逻辑运算符 not and or (if elif)
      2. if Ture:
      3. ## program
      4. else:
      5.     ## program
      6.     
      7. if A and B(A or B):  ## if not A:
      8.     ## program
      9. else:

    ## program

注：添加编程训练，从键盘输入两个数，判断大小，并输出显示较大的数。

输入第一个数：

输入第二个数：

如果 第一个数大于第二个数:

​ 输出第一个数

再如果 第一个数等于第二个数：

​ 输入有误

否则

​ 输出第二个数

1. 1. 1. 循环结构，包含有whie , for。若想停止循环，可以选择break; 进行下一次分支语句，continue; pass语句表示什么都不执行，进行占位

C/C++语言中

for( int i=0 ; i< 6; i++)

{

​ // program...

}

int i=0

while(i<10)

{

​ i++;

​ //program;

}

for i in range(10):

print(i)

以及对应的while循环

while True:

print("hello")

time.sleep(1)

    

python中的占位符。

常用的range循环结构，重点掌握其中的前四个

序列	Python	C/C++/Java
[0,1,2,…,9]	range(10)	for (i=0; i<=9; i++)
[0,1,2,…,n-1]	range(n)	for (i=0; i
[n-1, …, 1, 0]	range(n-1, -1, -1)	for (i=n-1; i>=0; i--)
[1,2,…,n]	range(1, n+1)	for (i=1; i<=n; i++)
[1,2,3,4 ……	import itertoolsfor i in itertools.count(1):	for (i=1; ; i++)
小于n的奇数	range(1, n, 2)	for (i=1; i
所有奇数	import itertoolsfor i in itertools.count(1,2):	for (i=1; ; i=i+2)

1. 猜数字：
2. 随机产生一个1～100的正数， 从键盘输入一个正整数，程序判断告诉：输入数据大了，还是小了。最终找到这个数字。
3. import random
4. #生成1~100任意的一个随机数
5. randNum=random.randint(1,100)
6. while True:
7.     number=float(input("请输入一个100以内的数:")) #键盘输入一个100以内的数
8.     if(number>randNum): #如果大于输出 "输入值偏大"
9.         print("输入值偏大")
10.     elif(number#如果小于输出 "输入值偏小"
11.         print("输入值偏小")
12.     else:            #相等输出 “数值正确”
13.         print("数值正确")
14.         break

​

输出1--100之间能够被3整除的整数：

for num in range(100):

    if num%3==0:

        print(num,end='\t')

 

python函数的定义

1. 格式 def + 函数名（传递参数）: 函数体， return
2. def fool(a,b):
3. return a+b

print(fool(1,2))

1. 返回类型可以是多个变量，返回值为一个列表，可以通过列表的访问形式进行访问; 也可以采用多个返回值来表示。
2. def fool(a,b):
3. return a+b, a

c,d = fool(1,2)

1. 传递参数可以有默认值；传递参数可以是对象，且对象不必添加类名字
2. 函数名建议采用驼峰命名法

python中的类

1. 讲不同的类型放在一起，组成一个整体，形成类。类的出现方便的数据的管理，利于程序的编写，是面向对象变成的体现。类包含有自己的属性，对外提供的方法，以及类内的函数。C++中对类的描述分为public, protect, private三种属性。一般采用public表示对外提供的接口以及方法，采用protect和private表示保护以及私有属性，保护以及私有属性，一般在类外不能访问。在python的编程中，建议采用相同的编程逻辑。
2. 格式 class 类名（父类）： 类体
3. class Person():
5. ​         def __init(self,name="liming", age = 18, classname="classthree")__:
7. ​ self. name = name
9. ​ self. age = age
11. ​ self. classname = classname
13. ​        def ShowName(self):
15. ​            return self.name

​        ......

1. 对象的建立 person = Person() 表示建立默认的对象，由于没有指定传递参数，采用默认的传递参数。也可以在建立对象的时候指定传递参数。比如 person1 = Person("xiaohau", 20, "classone")
2. 一般采用类中提供的方法实现功能（方法即为类中对外提供的函数）
3. 类的封装性：只对外提供想要的实现，对类内封闭的属性进行封装。python中允许直接方针对象的属性

练习题目：创建一个汽车类，包含有汽车的名字，车长，车重， 并创建实现方法显示其中的属性。

练习题目： 在游戏中为了增加互动性，通常会创建一个游戏角色，该角色具有一定的属性，比如性别，名字，初始生命值。 我们假设，当受到一次攻击时，生命值会减少10， 当生命值小于等于0时，角色死亡；当击打别人一次，经验值增加10， 当经验值大于50的时候，升级。请编程模拟该过程。初始人物为 {” Little Boy“， male, 100}, 受到2次攻击，同时击打别人5次的过程。

类中的继承 待补充

python中采用import导入外部pack或者外部程序

1. 具体写法为import Person 表示引入Person.py的文件，同时可以使用Person.py文件中的内容
2. import numpy as np表示引入numpy的同时给numpy起一个别名np，后面在使用的时候，可以采用np来代替numpy.
3. 本节课中常用的外部包有numpy, time, math, matplot, tensor

练习从另一个.py文件中，引入变量，函数，类。

例：从键盘输入两个整数，调用四个函数，分别显示输出+-*/（加减乘除）

def functionAdd(num1,num2): #加法

    return num1+num2

def functionSub(num1,num2): #减法

    return num1-num2

def functionMul(num1,num2): #乘法

    return num1*num2

def functionDiv(num1,num2): #除法

    if not num2:

        return 99999

    return num1/num2

if __name__=='__main__':

    #请输入数字

    num1= int(input('Please input a  number:'))  

    num2= int(input('Please input a  number:'))

    

    #打印加减乘除的结果

    print(functionAdd(num1,num2))

    print(functionSub(num1,num2))

    print(functionMul(num1,num2))

    

    #除法判断是否有误

    divResult =functionDiv(num1,num2)

    if divResult ==99999:

        print('the second is zero...wrong input')

    else:

        print(functionDiv(num1,num2))

汽车类型代码

#这是一个Car类

class Car():

    '''

    kind : 车的品牌

    length ：车的长度

    weight ： 车的重量

    '''

    def __init__(self,kind='BMW',length=4.5,weight=1.6):

        self.kind=kind

        self.length=length

        self.__weight=weight #__weight 表示私有属性 不能直接调用

        

    #显示车的重量

    def showWeight(self):

        return self.__weight

    

#初始化Car类

BMW=Car()

#打印车的每个属性

print(BMW.kind)

print(BMW.showWeight())

print(BMW.length)

 

list 介绍： 列表 a = list()，我们通常采用list来记录中间变量，采用如下方式完成数据的添加和弹出，以及删除

list常用的API函数， max(), min(), len(), list()

函数名	功能
max()	返回list中的最大值
min()	返回list中的最小值
len()	返回list的长度
list()	将元祖强制转换成一个list

注：下式中的两句等同

a  = list('hello')

b  = list("hello")

list中的常用方法(Method), append, count, index, insert, pop, remove, reverse, sort

方法名	功能	示例
append	从列表末尾追加新元素	a_list.append(1)
count	统计某元素在列表中出现的次数	a_list.count(2)
index	返回从列表中查找第一个匹配项的索引值	a_list.index(2)
insert	在列表中插入某值	a_list.insert(3,'m')
pop	移除列表最后一个值，返回移除的值	a_list.pop()
reverse	列表中的所有元素反向排列	a_list.reverse()
sort	对列表中的元素进行排序（相同数据类型）	a_list.sort()

思考题：

  c = list([1,2,"h","hello",1.23])， 此时是否存在max(c), min(c), 以及len(c)

a = list()

a.append(1)

a.append(2.3)

a.append("hello")

a.pop()

a.remove(2.3)       #指定删除列表中相应的值

list中数据的访问,采用[]的形式对列表的数据进行访问，支持切片访问

a = list()

for i in range(10):  #从0-9的10个数

a.append(i)

print(a[1])

print(a[3:6])       #打印列表中[3:6]的数据，其中不含末尾项

Numpy介绍

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

• 一个强大的N维数组对象 ndarray
• 广播功能函数
• 整合 C/C++/Fortran 代码的工具
• 线性代数、傅里叶变换、随机数生成等功能

Numpy的导入

import numpy as np

np.array([2,3,4],[1,2,3])可以理解为生成一个两行三列的矩阵

np.zeros((3,2))表示生成一个3行2列的矩阵，

numpy中数组创建函数

函数	说明
array	创建一个数组，可以直接指定数据类型
arange	类似于内置的range, 但是返回的是一个ndarray而不是一个列表
ones	全1数组
zeros	全0数组
empty	创建一个新的数组，只分配内存空间但不填充任何值
eye/identity	创建一个N维的单位矩阵

numpy中的随机数产生

np.random.rand(2,3)   #均匀分布

np.random.randint(2,8,size=(3,2))

np.random.randn(3,3)   #正态分布

numpy中的数据类型，dtype进行， 例如

a = np.array([2,1,3],dtype=np.int16 )

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

数组属性

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息
ndarray.real	ndarray元素的实部
ndarray.imag	ndarray 元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

重点函数

函数名	说明	示例
reshape	不改变数据的条件下修改形状	a = np.arange(10).reshape(2,5)
transpose	对换数组的维度	a.transpose()
squeeze	从数组的形状中删除一维条目	a.squeeze()
sin()、cos()、tan()	np中的三角函数

游戏设计

class Game():      #创建一个类

    def __init__(self, name, sex, hp, exp):#定义def函数，__init__类方法中，self只有一个，属性为：name、sex、hp, exp

        self.name = name

        self.sex = sex

        self.hp = hp

        self.exp = exp

    def showhp(self):   #定义def函数，showhp()为类方法

        self.hp -= 20   #减运算，当人物被攻击一次是生命值（hp）将会减20

        if self.hp <= 0:#判断语句，当人物的生命值小于等于0时，输出打印：your hero is dead...，否则pass

            print('your hero is dead...')

        else:

            pass

        return self.hp

    def showexp(self):  #定义def函数，showexp()为类方法

        self.exp += 50  #加运算，当人物被攻击一次经验值（exp）加50

        if self.exp == 50:#判断语句，当人物的经验值等于50时，输出打印：你升级了，否则pass

            print('你升级了')

        else:

            pass

        return self.exp

if __name__ == '__main__':#main函数

    Button = str(input('是否开始游戏 y/n '))

    #输入语句，在input中标明y/n,将输入值转换为str类型，赋值给Button变量

    if Button == 'y':

        Player1 = Game(name='Little Boy', sex='male', hp=100, exp=0

        #创建对象Player1，定义人物属性

        for i in range(3):#循环语句（for），每循环一次就调用showhp方法，直到循环3次结束

            Player1.showhp()

        for i in range(5):#循环语句（for），每循环一次就调用showexp方法，直到循环5次结束

            Player1.showexp()

    else:

        pass

    print('你剩余的生命值为')

    print(Player1.hp)    #访问类属性

 

pandas是强大的结构化数据分析工具，可以用于数据挖掘与数据分析，也可以用于数据清洗。

pandas的数据结构有Serials形式，以及dateframe形式。

import pandas as pd

c = pd.Series([1,2,3,4,6,6,7])

print(c)

import pandas as pd

import numpy as np

c = pd.Series([1,2,3,4,np.nan,6,7])#创建一个索引函数Series的一维数组，nan不是一个数，是一个float类型的数据，所以相关计算都无法得到数字

print(c)

d = pd.DataFrame(np.arange(12).reshape((3,4)))#定义一个数据框，分别是以3行4列，数据是0~12排列组成的数据表

print(d)

df = pd.Series(['a',1,3,5.0])#创建一个索引函数Series的一维数组，包括字符、整型、float类型

print(df)

print(df.index#查看索引，输出打印RangeIndex(start=0, stop=4, step=1)，start为起点、stop为终止、step为歩长

print(df.values#返回视图对象，输出打印['a' 1 3 5.0]

s = pd.Series([1,2,3,4,5],index=['a','b','c','d','e']#创建一个索引函数Series的一维数组，然后index作为标量序号

print(s)

s3 = {'h':1,'b':2, 'm':3}#定义一个以h、b、m为1、2、3数值的序号数组

s4 = pd.Series(s3) #将创建好的数组s3利用索引函数Series进行整理赋值给s4

print(s4)

d = pd.read_csv('ab.csv',delimiter=',') #pandas提供了pd.read_csv()方法可以读取其中的数据，返回DataFrame文件，利用逗号(,)隔开

print(d)

d.loc[0,'chinese'] = 60 #索引从第0行开始查chinese成绩等于60分

print(d)

# print(d.loc[0,'chinese']) #输出打印索引从第0行开始查到chinese成绩等于60分

# print(d.iloc[1,:])#通过整数索引第1行号获取行数据，不能是字符

ab.csv中数据如下:

name,chinese,math lihua,98,99 xiaozhang,95,60 xiaoli,100,59 xiaowang,60,86

 

电脑中时会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的.

进程想要执行任务就需要依赖线程。换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。

实现多线程是采用一种并发执行机制.

并发执行机制原理：简单地说就是把一个处理器划分为若干个短的时间片，每个时间片依次轮流地执行处理各个应用程序，由于一个时间片很短，相对于一个应用程序来说，就好像是处理器在为自己单独服务一样，从而达到多个应用程序在同时进行的效果 [3] 。

多线程就是把操作系统中的这种并发执行机制原理运用在一个程序中，把一个程序划分为若干个子任务，多个子任务并发执行，每一个任务就是一个线程。这就是多线程程序 [3] 。

多线程的优势:

​ 1、使用线程可以把占据时间长的程序中的任务放到后台去处理 [4] 。

​ 2、用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度 [4] 。

​ 3、程序的运行速度可能加快 [4] 。

​ 4、在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等 [4] 。

​ 5、多线程技术在IOS软件开发中也有举足轻重的作用 [4]

多线程的缺点:

​ 1、如果有大量的线程，会影响性能，因为操作系统需要在它们之间切换 [4] 。

​ 2、更多的线程需要更多的内存空间 [4] 。

​ 3、线程可能会给程序带来更多“bug”，因此要小心使用 [4] 。

​ 4、线程的中止需要考虑其对程序运行的影响 [4] 。

​ 5、通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生 [4]

注: 本部分知识在本节课中并不做重点介绍

多线程主要API

函数名	作用	示例
threading.Thread	创建一个线程,并绑定一个回调函数	thread1=threading.Thread(target=functionName)
setDaemon	设置是否开启后台运行	thread1.setDaemon(True)
start	开启线程运行	thread1.start()

def printHello():

    while True:

        print("This is the hello threading...")

        time.sleep(1)

def printNihao():

    while True:

        print("This is the Nihao threading...")

        time.sleep(2)

if __name__ == '__main__':

    t1 = threading.Thread(target=printHello)

    t2 = threading.Thread(target=printNihao)

    t1.setDaemon(False)

    t2.setDaemon(False)

    t1.start()

    t2.start()

    print("main threading ended...")

倒计时游戏， 从60开始进行循环倒计时，每一秒自减一，按下按键‘b'，开始倒计时并显示， 按下按键’t'停止倒计时。

import time

import threading

begin = False

def numCounter():

    num = 60

    global begin

    while True:

        if begin:

            num = num -1

            print(f'num={num}, begin={begin}')

            time.sleep(1)

            if num<=0:

                num = 60

        else:

            pass

def keyDectect():

    # TODO:need to be revised by using the threading lock

    global begin

    while True:

        key = input()

        if key == 'b':

            begin = True

        elif key == 't':

            begin = False

        else:

            print('wrong input..')

if __name__ == '__main__':

    t1 = threading.Thread(target=numCounter)

    t2 = threading.Thread(target=keyDectect)

    t1.setDaemon(False)

    t2.setDaemon(False)

    t1.start()

    t2.start()