Python全栈2 - 初级课程

布满荆棘的人生 2022-06-18 13:16 276阅读 0赞

2、Python初级课程

**1、   Python 初识**

**2、Python 语法基础**

2-1 python常量与变量

2-2 python数与字符串

python中数的类型主要有5中：int long float bool complex

python中有时单引号和双引号要交叉使用

python中三引号引起来的字符串可以换行

‘’’

或者

“””

转义符\\

自然字符串print r” hello python\\n”

字符串的重复print “ hello python\\n”\*20

子字符串

1）索引运算符从0开始索引

2）切片运算符\[a:b\]是指从第a下标开始到第b-1下标，第一位的下标为0

2-3 python数据类型  （Python中无数组）

数

字符串

列表lst=\[“a”,”b”\] 读修改

元组tpl=(“a”,”b”) 只读

字典dic=\{‘’name”:”yx”, “age”:27\}

集合定义：集合中的元素具有唯一性功能：1）建立关系 2）消除重复  格式：set(“abcafdefg”)

2-4认识python标识符

只能以字母或下划线开始

区分大小写

常用关键字 一共有28种 如：print  import

2-5 python对象

在python中，一切皆是对象

pickle \#腌制

为了将对象持久性存储

序列化对象

恢复对象

代码：

import pickle

\#dumps(object)将对象序列化

lista=\["mingyue","jishi","you"\]

listb=pickle.dumps(lista)

\#print listb

\#loads(string)将对象原样恢复，并且对象类型也恢复为原来的格式

listc=pickle.loads(listb)

\#print listc

\#dump(object,file),将对象存储到文件里面序列化

group1=("bajiu","wen","qingtian")

f1=file('1.pk1','wb')

pickle.dump(group1,f1,True)

f1.close()

\#load(object,file)将dump()存储在文件里面的数据恢复

f2=file('1.pk1','rb')

t=pickle.load(f2)

print t

f2.close()

2-6 Python行与缩进

逻辑行与物理行

行中分号使用

逻辑行后因使用分号

每个物理行末可以省略分号

行连接\\

缩进

逻辑行行首的空白是有规定的，逻辑行行首的空白不会导致程序执行出错

方法：空格或tab键

注释  \#

**3、Python核心编程基础教程之Python运算符、运算符优先级、表达式简介**

7/2 \#3

7.0/2 \#3.5

7/2.0 \#3.5

7//2 \#3

7%2 \#1

~ : 按位翻转 公式~x=-(x+1)

<<:左移 乘2

>>:右移 除2

3-4 有先级 – 程序或运算符执行顺序

1）  函数调用、寻址、下标

2）  幂\*\*

3）  翻转运算~

4）  正负号-2

5）  \* / %

6）  + -

7）  << >>

8）  & | ^

9）  比较运算符

10）not and or

11）lambda表达式

3-5 Python运算符优先级的基本规律与特点

技巧（）

3-6 Python表达式 – 值、变量和运算符的任意组合

单行命令中，会弹出结果

源程序中，不会有弹出结果

表达式执行结果与print结果的区别：

>>> "qq"

'qq'

>>> print "qq"

>>> a = 7

>>> a

>>> print a

**4、Python 控制流**

顺序

选择

循环

b = False

while b:

print "A"

else:

print "B"  \# 只执行一次

contiue可以控制其下面的语言不执行，控制不了其上面的语句

continue与break的区别：

continue – 不执行本次循环的剩余语句，继续下一轮循环

break– 直接结束该循环的剩余所有次循环

**5、Python函数** – 功能

5-1 认识函数

分类：系统自带的函数自定义的函数

len() – 取字符串长度

>>>b="student".split("u") \# 字符串切割

>>> print b

\['st', 'dent'\]

5-2 形参与实参

形参– 在函数的定义过程中，一般指参数的名称

实参– 函数调用时，一般指参数具体的值

参数传递– 默认按照位置传递，将实参传给形参

关键参数– 按照关键字传递

5-3 全局变量与局部变量

作用域

局部变量– 在一定的范围内起作用，如：函数里面的变量

全局变量– 在全部的程序内起作用

global i

5-4 函数的使用（调用）与返回值

函数的返回值是通过return语句实现

返回一个值

返回多个值

def test(i,j):

k=i\*j

return (i,j,k)  \# 元组的形式返回多个值

x=test(3,4) \# 以一个变量存储元组

print x

y,z,m=test(3,5)  \# 以多个变量分别存储多个返回值

print y

5-5 文档字符串

\#文档字符串

def d(i,j):

'''A这个函数实现一个乘法运算。           \# 第一行概述

\# 第二行空格

函数会返回一个乘法运算的结果。'''        \# 第三行以后不空

k=i\*j

return k

\#print d.\_\_doc\_\_

help(d)

**6、Python 模块**

6-1 认识Python模块

模块– 函数的扩展，实现一类功能如，C:\\Python27\\Lib中的文件

函数实现一项功能

如何导入模块

>>> import math

>>> math.pi

3.141592653589793

sys模块 – 标准库中，与系统功能有关的模块

>>> import sys

>>> sys.version  \# 查看系统的版本信息

'2.7.11 (v2.7.11:6d1b6a68f775, Dec  5 2015, 20:32:19) \[MSC v.1500 32 bit(Intel)\]'

>>> sys.executable   \# 当前运行程序的目录地址

'C:\\\\Python27\\\\pythonw.exe'

>>> sys.getwindowsversion()  \# 返回Windows系统的版本信息

sys.getwindowsversion(major=6, minor=1,build=7601, platform=2, service\_pack='Service Pack 1')

>>> sys.modules.keys()  \# 返回已导入的模块

6-2 字节编译

Python中的两种执行方式：

1)         将模块里的内容编译成二进制语言，在执行

2)         直接执行对应模块的二进制语言程序

字节编译- 把模块编译成二进制语言的过程

Python中的字节编译是在解释器中完成的，因此Python仍然解释性语言

.pyc文件 – 经过编译后的模块二进制文件

.pyc文件的两种产生方式：

1)         运行.py的文件就会产生（直接import对应的模块），如，import zipfile之后出现

2)         在cmd中 python –m compileall xmllib.py

.pyc文件的作用：加快模块的运行速度 反编译

查看.pyc文件内容：binary viewer

6-3 from…import详解 – 导入模块中的功能

from（模块）import（某个方法）

from…import\* - 导入所有属性和方法

6-4 认识\_\_name\_\_属性

主模块– 这个模块是被直接使用，自己执行，没有被别人调用，模块的\_\_name\_\_属性的值是\_\_main\_\_

非主模块– 这个模块被别人调用（被import时），模块的\_\_name\_\_属性的值不是\_\_main\_\_

\_\_name\_\_属性的使用 – 判断这个模块是不是主模块（判断模块的执行方式）

6-5 自定义模块

系统自带模块

自定义模块– 将Python程序保存在Lib目录下

自定义模块使用：

在模块内，将参数初始化（或者声明参数的类型int i），保证模块没有逻辑和语法错误

将参数的值从模块的外面传递到模块里面

6-6 dir()函数 – 查看一下指定模块的功能列表

>>> import sys

>>> dir(sys)

dir()函数扩展详解 – 查看任意指定对象的功能列表

>>> d=\[\]

>>> dir(d)

>>> e=90

>>> dir(e)

**7、Python 数据结构初识**

7-1 数据结构概述 – 数据的组织方式

内置数据结构– 列表\[\]、元组()、字典\{\}

扩展数据结构– 栈、队列

数据结构（静态）与算法（动态）的关系

栈– 一端开的容器

\# coding=utf-8

\# 栈的实现

class Stack():

def \_\_init\_\_(st,size):

st.stack=\[\]

st.size=size

st.top=-1

def empty(st):

if st.top==-1:

return True

else:

return False

def full(st):

if st.top==st.size:

return True

else:

return False

def push(st,data):

if st.full():

print "Stack is full"

else:

st.stack.append(data)

st.top=st.top+1

def pop(st):

if st.empty():

print "Stack is empty"

else:

st.top=st.top-1

队列– 两端都开得容器，进行插入操作的一段叫队尾，进行删除操作的一段叫队首

数据的流量只能是单向的

\# coding=utf-8

\# 队列的实现

class Queue():

def \_\_init\_\_(qu, size):

qu.queue = \[\]

qu.size = size

qu.front = -1

qu.rear = -1

def empty(qu):

if qu.front == qu.rear:

return True

else:

return False

def full(qu):

if qu.rear - qu.front + 1 == qu.size:

return True

else:

return False

def enQueue(qu, data):

if qu.full():

print "Queue is full"

else:

qu.queue.append(data)

qu.rear += 1

def outQueue(qu):

if qu.empty():

print("Queue is empty")

else:

qu.front -= 1

**8、Python 数据结构进阶**

**9、Python 算法入门详解**

**10、Python 的面向对象程序设计**

对象– 将每个复杂的事物拆分为不同的部分，其中每个部分称之为对象

面向对象的特点– 易维护；效率高；质量高；易扩展

类– 某些对象之间的共性的抽象

类与对象的关系– 类是对象的抽象，对象是类的具体表现形式，也叫做类的实例

代码：

\#类和对象的实现

\#类的实现，建立一个类的格式是：class 类名

class man:

pass                         \#**pass**属于空语句，无意义，目的是为了保证程序的完整性，叫做占位语句

\#print man

\#对象的实现，建立了类之后，再建立一个类的对象（也叫类的实例），建立对象的方式可以直接在类后面加小括号即可

class woman:

pass

w=woman()

\#print w

\#以上我们实现了在一个类下创建了一个对象。这里，很多同学会问，之前我们不是说一个类型里面可以有多个例子吗？这里

\#为什么只创建了一个对象？包括很多参考书上在这里没有点破，造成了很多初学者对这个问题的困扰。其实，在一个类下确

\#实是可以建立多个实例的，我们且看下面的程序：

wangdama=woman()

lidama=woman()

zhangdama=woman()

\#print wangdama

\#print lidama

\#print zhangdama

\#这里，很对人可能又会疑问，我们都是将woman()赋给了前面一个实例，那是不是就是说前面这几个实例是一样的呢？

\#不是的，我们虽然都是将woman（）赋给了前一个变量（实例），但是具体意义是不一样的。这句话的意思只是说将

\#woman这种类型赋给某个对象，只要对象名不一样，那么每个对象所占的存储内存也是不一样的，也就是说，这几个

\#对象间可以互不影响。这一点，我们观察每个实例的内存就可知道。

方法– 一个是实例的功能 – 动态 –方法代表对象的操作

属性– 静态 – 属性代表对象的数据

创建实例属性和实例所对应的类属性

\_\_init\_\_(self): 构造函数

\_\_del\_\_(self): 析构函数

代码：

\#方法及属性的实现

class woman:

pass

wangdama=woman()

\#如何查看一个实例具有哪些属性？

\#print wangdama.\_\_dict\_\_

\#如何为一个实例添加属性？

wangdama.toufa="huangse"

\#print wangdama.\_\_dict\_\_

\#为其中一个实例添加了某属性之后，该类中的其他实例的属性是否会受影响？

lidama=woman()

\#print lidama.\_\_dict\_\_

\#如何查看一个实例所属类的属性？

\#print wangdama.\_\_class\_\_.\_\_dict\_\_

\#如何给某个实例所属类添加属性？

wangdama.\_\_class\_\_.xiezi="heise"

\#print wangdama.\_\_class\_\_.\_\_dict\_\_

\#在修改了其中一个实例的属性后，该实例所属类的其他实例类属性是否会受影响？

\#print lidama.\_\_class\_\_.\_\_dict\_\_

\#所以我们得出结论：在单独修改某个实例属性时，其他实例属性不受影响。若修改类属性，那么该类下所有实例类属性均受影响

\#上面我们讲了属性如何创建，下面我们来说方法如何创建。

class god:

def a(self):                    \#这里的self是必须的，所有的方法，第一个参数必须是self，代表所有实例共享他，不具备其他任何含义

print "所有人必须明天唱一首歌"

zongguan=god()

\#zongguan.a()

\#问：我们可以不通过实例调用方法而直接通过类去调用方法吗？答案：不可以

\#god.a()

\#我们可以看得到，其执行会出错。有人说，为什么下面这种形式可以？

\#god().a()

\#原因：有括号了，就已经是类的实例了，而不再是类。

\#隐藏属性与隐藏方法

class school:

def \_\_jiaoxuefangfa(self):

print "&^^\*&\*"

\#school().\_\_jiaoxuefangfa()

\#我们可以看得到，出现错误，找不到该方法，明明已经定义却找不到，因为这个方法做了隐藏（\_\_），隐藏后，在外面无法调用该方法

\#如果我们去掉下划线，我们发现，在外面就可以调用了

\#类常见的一些专有方法

\#1.\_\_init\_\_，构造函数

class people:

def hi(self):

print 8899

def \_\_init\_\_(self):

a="A:how are you?"

b="----B:Fine,thankyou"

print a+b

\#people()

\#2.\_\_del\_\_,析构函数

class friend:

def hi(self):

print 8899

def \_\_init\_\_(self):

print "我是init最先调用"

def \_\_del\_\_(self):

a="我是析构函数"

b="----对象生命周期结束啦，现在我得删除对象善后啦！"

print a+b

\#xiaohang=friend()

\#xiaohang.hi()

\#friend()

\#friend().hi()

单继承– 只有一个父类继承 \#class A(B)

多继承\#class A(B,C)

多继承方法冲突解决– 优先选择左边

**11、Python 异常处理与文件操作**

代码1：

\# Python异常的处理

\# 使用try…except语句，假如try出现了某种异常，则执行except下面的语句

try:

print i

except NameError:     \#这里一定要指明异常类型

i=9

i+=10

print "刚才i没定义，处理了异常之后，i的值为："+str(i)

\#处理多种异常

try:

print i+j

except NameError:

i=j=0

print "刚刚i或j没有进行初始化数据，现在我们将其都初始化为0，结果是："

print i+j

except TypeError:

print "刚刚i与j类型对应不上，我们转换一下类型即可处理异常，处理后：结果是："+str(i)+str(j)

异常引发

自动引发

自定义引发 – 使用raise来引发

代码2：

\# coding=utf-8

\# 异常的引发

\# 1/用raise引发一个系统的错误类

i=8

print i

if i>7:

print 9

raise NameError

print 10

\# 2/自定义一个异常并用raise引发

class RhhError(Exception):                 \#按照命名规范，以Error结尾，并且自定义异常需要继承Exception类

def \_\_init\_\_(self):

Exception.\_\_init\_\_(self)

try:

i=8

if i>7:

raise RhhError()

except RhhError,a:

print "RhhError:错了就是错了"

\# 3/自定义一个多参数的异常并用raise引发，比如我们可以定义一个异常，当x>2或者x+y>7的时候都会引发该异常

try…finally语句

代码3：

\# coding=utf-8

\#try…finally的使用

\#假如要实现不管中间是否发生异常，都要输出一串字符串

try:

i= 7

print i

finally:

print "不管上面是否异常，我必须输出！"

\#第二个例子：要实现将一串字符串输出10000000次，假如异常发生，需要判断前面已经输出了多少次。

try:

for i in range(10000000):

print "我要输出10000000次，现在正在输出中，也不知道现在是多少次了"

finally:

print "此时i的值是："+str(i)+"--并未完成全部输出"

文件操作

代码：

\#Python中文件的操作

\#创建文件

fc=open("G:/文件操作演示文件夹/a.mp3","w")

\#打开文件

fo=open("G:/文件操作演示文件夹/a.mp3","w")

\#写入和关闭文件---**写入文件四步曲**：先做好内容，然后建立文件，然后再写入，然后再关闭

content='''我是文件的内容

是文件的

内容呢

待会据说要把我写进去。。

'''

fw=file("G:/文件操作演示文件夹/a.txt","w")

fw.write(content)

fw.close()

\#然后学习了close是关闭之后，我们把a.mp3给关闭了

fc.close()

fo.close()

\#**读取文件**,关键点：先打开文件，在进入while循环依次读取每行

fr=file("G:/文件操作演示文件夹/a.txt")

while True:

line=fr.readline()

if len(line)==0:

break

print line

fr.close

**12、Python 标准库与其他应用**

标准库–系统自带安装的库

位置：C:\\Python27\\Lib

sys模块 – 主要处理系统相关的功能

代码：

\# coding=utf-8

import sys

\# 接受命令行传来的参数

print sys.argv\[0\]

\# 查看版本

print sys.version

\# 退出

sys.exit(0)

Python全栈2 - 初级课程

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Python全栈开发，Day2

相关 2.6【微信小程序全栈开发课程】添加底部导航

相关 PHP H5全栈工_______ 课程大纲（大概）

相关 Python全栈1 - 快速入门与web2py

相关 Python全栈9 - Tornado

相关 Python全栈2 - 初级课程

相关 mpvue课程小程序全栈开发学习记录

相关全栈技术实践2

相关 Python全栈工程师

相关 PHP全栈学习笔记2