首页  思维导图  详情

计算机语言学习

2019-10-15 10:06:26   0  举报





AI智能生成

python基础学习

Python

作者其他创作

大纲/内容

Python学习

打印方式

print() 打印

print("Hello,world!")#全部使用英文符号

变量

变量的作用

作为一个临时存储的中间值,昵称其代指内存里某个地址中保存的内容

变量的运行过程

a=1

起了一个变量名 : a

有一个值 : 1

将值赋给变量名 : =

定义变量的规则

字母,数字,下划线组成

不能以数字开头

区分大小写

不要用中文或拼音

命名要有意义

不能用Python关键字命名

推荐使用驼峰或下划线的方式命名

常量

常量就是将变量名大写,尽量保持不更改的一种量

注释

作用

给一些不太能够理解的写一个描述,让自己或他人更好的理解其含义

使用方式

单行注释

用#来注释,不能换行

多行注释

'''注释内容'''

Python基础数据类型初识

整型

Python2,3中差异

在python3中所有的整数都是int类型.
但在python2中如果数据量比较大. 会使用long类型.
但是在python3中不存在long类型

操作

bit_length(). 计算整数在内存中占用的二进制码的长度

可进行 + - * / 运算 int 表示

字符串

定义

Python中主要是用引号引起来的就是字符串,计算机中str表示字符串的意思

拼接方式

字符串和字符串之间可进行拼接,用+实现

字符串和数字可进行字符串的镜像拼接,用*实现

布尔值

Ture:真

False:假

运算符简单认识

算数运算

赋值运算

**=

//=

比较运算

逻辑运算

and

not

成员运算

not in

身份运算

位运算

用户交互

input("提示语句")

Python2

#将用户输入的内容赋值给name变量
#python2的写法
name = raw_input("请输入用户名:")
print name

Python3

#python3的写法
name = input("请输入用户名:")
print(name)

#Python3版本中 input 获取到的内容全部都是字符串类型验证如下
my_input=input("请输入")
print(type(my_input))
#打印的结果显示my_input<class "str">str就是字符串的意思.

流程公式语句 if

单纯选择判断

if 1>0:#条件判断用 > < == 符号来进行,注意用冒号结束.
print("打印要求")#条件成立后执行,注意要有缩进符,使用Tab实现缩进.

二选一选择判断

if 1>0:
print("打印要求")
else:#当if不成立时是执行.
print("打印要求")#当else成立时执行操作.

多个选项进行单选

num = 1
if num == 1:
print('打印要求')
elif num == 2:
print('打印要求')
elif num == 3:
print('打印要求')
else:
print("打印要求")#当num不满足以上条件要求时else才成立

多个选项进行多选

num = 1
if num == 1:
print('打印要求')
if num == 2:
print('打印要求')
if num == 3:
print('打印要求')
#此判断可以进行多个判断进行多个选择.
#与单选判断的区别是单选判断时当满足一个条件要求后不再判断其它的条件.

if 嵌套

name = input('请输入名字:')
if name == 'meet':
age = 18
if age == 18:
print('打印要求')
else:
print('打印要求')
else:
print('打印要求')
#可以进行多次嵌套判断,要灵活运用,前后逻辑要通顺.

字符串的格式化

意义

按照既定的要求进行有规定排版的一种输出方式

使用方式

非占位符方式

占位符方式

占位符简单解释

% 表示占位符,占位符后接数据类型,数据类型有多种类型

主要用于格式化输出

Python初期%衔接的常用数据类型

%s 用str()进行转化后填充至占位符位置(%s也称为任意占位符)

%d 转成有符号十进制数,主要是用于嵌入整数

%% 在格式化输出中用来表示百分号,用来区分百分号和占位符,所以用2个%%表示

注意事项

在格式化输出出中,使用占位符%后衔接的数据类型不可以用大写字母代替,占位符及其对应的嵌入元素要一一对应,不多不少

f '''{}''' 方式

介绍

大括号计算机默认就是占位符的位置,同时大括号里的内容一般都放变量,注意区分引号做好区分

适用范围

python3.6之后的版本可用

while循环

简介

while是一个关键字,while跟随的是条件以冒号结尾,
当条件成立开始向下执行,同时循环直至while条件不成立为止

while本身相关关键字

break

作用是终止当前while所属循环层

continue

跳出本次循环,继续下次循环

else

当while循环正常结束后执行此操作

初识编码

常见编码

ASCII

ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号,只支持英文,英文1个字节

GBK

GBK, 国标码占用2个字节. 对应ASCII码 GBK直接兼容. 因为计算机底层是用英文写的. 你不支持英文肯定不行. 而英文已经使用了ASCII码. 所以GBK要兼容ASCII.英文1个字节,中文2个字节

Unicode

Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的.

它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536，最少英文占2个字节,中文占4个字节

UTF-8

UTF-8 是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：英文占1个字节,欧洲2个字节,东亚3个字节

单位转化

- 8bit=1Byte (1个字节=8位)
- 1024B=1KB
- 1024KB=1MB
- 1024MB=1GB
- 1024GB=1TB
- 1024TB=1PB
- 1024PB=1EB
- 1024EB=1ZB
- 1024ZB=1YB
- 1024YB=1NB
- 1024NB=1DB

for 循环

用法

我们可以使用for循环来便利(获取)字符串中的每一个字符

语法

for 变量 in 可迭代对象:
pass

可迭代对象

可以一个一个往外取值的对象

in用法

在for中

是把每一个元素获取到赋值给前面的变量

不在for中

判断xxx是否出现在str中

range用法

语法

range(start,end,step)

start

起始位置

end

结束位置

step

步长

注意

顾头不顾尾,当range(10)为此形式时,起始位置默认从0开始到9结束,打印10次

列表

意义

列表是python的基础数据类型之一,其他编程语言也有类似的数据类型.
比如JS中的数组, java中的数组等等,它是以[ ]括起来, 每个元素用","隔开并且可以存放各种数据类型

优点

列表相比于字符串,不仅可以存放不同的数据类型,并且可以存放大量的数据.当32位Python可以存放:536870912个元素, 当64位Python可以存放:1152921504606846975个元素,并且列表是按照你保存的顺序进行排序的,有索引并且可以切片,方便取值

列表索引,切片,列表操作和列表嵌套

列表索引

列表与字符串一样也有索引

列表切片

列表与字符串一样可进行切片操作

列表的操作

注意

list和str不一样, lst可以发生改变.,所以可以直接在原来list对象上进行操作

分为五种

增

删

列表的删除有四种方式(pop,remove,clear,del)

改

查

列表是一个可以迭代的对象

其它

列表嵌套

一层一层看灵活运用即可,融会贯通

元组

意义

元组俗称不可变的列表,又称为只读列表,元组也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,循环也可以,查询可以,切片也可以,就是不能改

注意

这里元组的不可变的意思是当子元素是不可变对象时元素不可变,当子元素为可变对象时是可以变的, 这取决于子元素是否是为可变对象.

元组中如果只有一个元素,需要添加一个逗号,否则就不是一个元组,当tu=()时,print(type(tu)),打印结果显示tu是元组

元组的操作

元组也有,len(),count(),index()等方法,可以自己尝试直至融会贯通

字典初识

定义

字典(dict),是python中唯一的映射类型.他是以{ }括起来的键值对组成.在dict中key是唯一的

语法

{key1: value1, key2: value2....}

注意

key必须是不可变(可哈希)的. value没有要求,可以保存任意类型的数据,字典保存的数据时是无序的,因此不能用索引查找,只能用key来获取字典中的数据.

小数据池

什么是小数据池

小数据池就是python中一种提高效率的方式,固定数据类型,使用同一个内存地址

小数据池 is和==的区别

== 判断等号俩边的值是否相同
is 判断两个内存地址是否相同

小数据池和代码块的关系

注意 : 先执行代码块后执行小数据池

小数据池 : 支持str,int,bool
数字范围 : -5~256
字符串 : 1.在做乘法的时候总长度不能超过20
2.自定义的字符串,长度不限制,字符串必须(字母,数字,下划线)组成
3.特殊字符(中文除外)定义一个时候,进行驻留
4.字符串*1,其实就是赋值*

代码块 : 一个文件,一个模块,一个函数,一个类
数字 : 全部驻留
字符串 : 1.字符串做乘法的时候总长度不能超过20
2.自定义的都驻留
3.字符串*1,其实就是赋值
4.python3.7 乘法的时候总长度不能超过4096

集合

集合介绍

- 什么是集合 : set就是dict类型的数据但是不保存value,只保存key.set也用{}表示
- 关键字 : set
- 集合特点 : 集合是可变的,集合内的元素是无序的,元素不可变并且唯一,天然去重

集合操作

增

set.update()迭代添加
set.add()集合添加

删

set.pop()随即删除
set.remove()制定元素删除
set.clear()清空元素
del s 删除整个集合

改

删除后添加

查

for查找

其它

print(s1-s2)差集
print(s1|s2)并集
print(s1&s2)交集
print(s1^s2)反交集
print(s1>s2)父集
print(s1<s2)子集

冻结集合

把可变的转换成不可变的
frozenser()

s = frozenset(["武当","少林","峨眉","丐帮"])
dic = {s:'123'} # 冻结s后就可以正常使用了
print(dic)

深浅拷贝

深拷贝

深度拷贝,把元素内部的元素完全进行拷贝复制,一个改变另一个不会跟着改变,当使用深拷贝时需要调用import copy.

import copy
lst1 = ["张三丰","乞丐","方丈",["祥龙","伏虎","罗汉"]]
lst2 = copy.deepcopy(lst1)
lst1[3].append("灭绝")
print(lst1) # ["张三丰","乞丐","方丈",["祥龙","伏虎","罗汉","灭绝"]]
print(lst2) # ["张三丰","乞丐","方丈",["祥龙","伏虎","罗汉"]]
print(id(lst1[3]), id(lst2[3])) # id不同
# 元素内部的元素完全进行拷贝复制,一个改变另一个不会跟着改变

浅拷贝

浅拷贝,只会拷贝第一层,二层的内容不会拷贝,所以被称为浅拷贝

lst1 = ["张三丰","方丈","乞丐"]
lst2 = lst1.copy()
lst1.append("灭绝")
print(lst1)
print(lst2)
print(id(lst1), id(lst2))
# 两个lst完全不一样,内存地址和内容也不一样,但是实现了内存的拷贝
---------------------------------
lst1 = ["张三丰","乞丐","方丈",["祥龙","伏虎","罗汉"]]
lst2 = lst1.copy()
lst1[3].append("灭绝")
print(lst1) # ["张三丰","乞丐","方丈",["祥龙","伏虎","罗汉","灭绝"]]
print(lst2) # ["张三丰","乞丐","方丈",["祥龙","伏虎","罗汉","灭绝"]]
print(id(lst1[3]),id(lst2[3])) # id相同
# 只会拷贝第一层,二层的内容不会拷贝,因此第二层元素发生改变则都会改变.

数据类型深入了解

数据类型转换

- str-int 字符串中必须都是十进制的数,才能进行转换
- int-str 正常转换没有限制
- str-list 用split转
- list-str "".join(list) 不能有数
- list-tuple 正常转换没有限
- tuple-list 正常转换没有限
- set-list 正常转换没有限
- list-set 正常转换没有限制

数据类型操作注意事项

- 循环删除索引的时候,要倒序删除否则会报错,或者结果不正确
- 循环添加列表元素的时候,会形成死循环
- 字典再循环的时候不能改变字典的大小
- 先定义一个列表循环列表列表删除字典

文件操作

基本操作

1. 打开文件 open
2. 操作文件 read or write
3. 关闭文件 close

语法

f=open("文件",mode="模式",encoding="编码")

- open() # 调用操作系统打开文件
- mode() # 对文件的操作方式,("")内填入文件的操作方式.
- encoding= # 文件的编码,=""跟着编码方式
- f # 文件句柄

注意事项

使用原生字符可以解决\的问题,在"文件"前加r)

# 不使用r时
f=open("D:\\Git\\Git存储\\学习.txt",mode="r",encoding="UTF-8")
# \\用来和python中的一些关键字做区分,不用\\表示可能会出错
---------------------------------
# 使用r时
f=open(r"D:\Git\Git存储\学习.txt",mode="r",encoding="UTF-8")
# 此时的r是repr的简称,repr作用是保持原始状态消除关键字功能.

函数

函数初识

- 函数 : 函数是以功能为导向,一个函数封装一个功能.
- 面向过程缺点 : 代码重复,代码描述性不高
- 函数的优点 : 减少代码重复性,增强了代码的可读性

函数结构

# 结构
def 函数名():
内容
# def : 定义一个函数,def关键字后紧跟一个空格
# def 函数名() : 函数名命名方式与变量命名规范一致

函数调用

# 结构
def 函数名():
内容
函数名()
# 函数名() : 函数的执行
---------------------------------
# 函数的执行写多少次,执行多少次
lis=[1,2,3,4,5,6,7,8,9]
def new_len():
count=0
for i in lis:
count+=1
print(count)
for i in range(3):
new_len() # 执行结果三次9

函数的返回值

return

作用1

只能在函数中用,可用于结束函数,后可以接判断

lis=[1,2,3,4,5,6,7,8,9]
def new_len():
count=0
for i in lis:
count+=1
print("少林")
return
print("武当")
new_len() # 少林

作用2

给函数的执行者返回具体的值（三种情况）

函数中没有return或只写一个return,函数的执行者得到的是None

lis=[1,2,3,4,5,6,7,8,9]
def new_len():
count=0
for i in lis:
count+=1
return
print(new_len()) # None

函数中return后跟单个值,则返回这个值,不改变值得类型

lis=[1,2,3,4,5,6,7,8,9]
def new_len():
count=0
for i in lis:
count+=1
return [1,2,3,4,5]
print(type(new_len())) # <class 'list'>

函数中return后跟多个值,函数的执行者得到的是一个元组

lis=[1,2,3,4,5,6,7,8,9]
def new_len():
count=0
for i in lis:
count+=1
return [1,2,3,4,5],123,"123"
print(type(new_len())) # <class 'tuple'>

迭代器

可迭代对象

字面意思分析

可以重复迭代的实实在在的东西,
list,dict,keys(),values(),tuple,str,set,range,文件句柄这些都属于可迭代对象

专业角度分析

内部含有'_ iter _'方法的对象,就是可迭代对象
内置函数 : dir()用来获取对象内部属性的方法,可用来判断对象是否符合可迭代要求.

优点

直观,操作方法较多

缺点

占用内存(字典除外),不能直接进行迭代取值,索引,字典key

迭代器

字面意思分析

可以重复迭代的工具

专业角度分析

内部含有'_ iter_ '并且含有'_ next _'方法的对象,就是迭代器
可迭代对象转化成迭代器用iter(),迭代器可以迭代取值,利用next()进行取值,迭代器一条路走到底,不走回头路

优点

非常节省内存,惰性机制

缺点

不直观,操作不灵活,效率相对低

生成器

生成器初始

生成器的本质就是迭代器,python社区中认为生成器与迭代器是一种

生成器与迭代器的唯一区别,生成器是我们自己用python代码构建成的

生成器产生方式

生成器函数

生成器表达式

python给你提供的一些内置函数,返回一个生成器

列表推导式与生成器表达式

列表推导式

一行代码构建一个有规律比较复杂的列表

循环模式

[变量(加工后的变量) for 变量 in iterable]

print([i for i in range(1,11)])
---------------------------------
print([f"python{i}" for i in range(1,101)])

筛选模式

[变量(加工后的变量) for 变量 in iterable if 条件]

print([i for i in range(1,101) if i%2==0])
---------------------------------
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
print([c for i in names for c in i if c.count("e")>=2])

列表推导式的优缺点

优点

简单,快捷

缺点

可读性不高,不好排错

生成器表达式

与列表推导式几乎一样,生成器时print打印的是地址,这是唯一不同点

循环模式

print((i for i in range(1,11))) # <generator object <genexpr> at 0x00000000021134F8>

筛选模式

print((i for i in range(1,101) if i%2==0)) # <generator object <genexpr> at 0x0000000001F134F8>

触发生成器(迭代器)取值方式

next(生成器)

for 内部用next(生成器)

list(生成器)

内置函数

eval：执行字符串类型的代码(解开并返回最终结果)

eval('2 + 2') # 4
n=81
eval("n + 4") # 85
eval('print(666)') # 666

exec:执行字符串类型的代码(只解开没有返回值)

s = '''
for i in [1,2,3]:
print(i)
'''
exec(s)

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

print(hash(12322))
print(hash('123'))
print(hash('arg'))
print(hash('alex'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

'''
-2996001552409009098
-4637515981888139739
1
2528502973977326415
'''

help：函数用于查看函数或模块用途的详细说明。

print(help(list))
print(help(str.split))

callable：函数用于检查一个对象是否是可调用的。
如果返回True，object仍然可能调用失败；
但如果返回False，调用对象ojbect绝对不会成功。

name = 'alex'
def func():
pass
print(callable(name)) # False
print(callable(func)) # True

int：函数用于将一个字符串或数字转换为整型。

print(int()) # 0
print(int('12')) # 12
print(int(3.6)) # 3
print(int('0100',base=2)) # 将2进制的 0100 转化成十进制,结果为 4

float：函数用于将整数和字符串转换成浮点数。

print(float(3)) # 3.0

complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。。

print(complex(1,2)) # (1+2j)

bin：将十进制转换成二进制并返回。

print(bin(10),type(bin(10))) # 0b1010 <class 'str'>

oct：将十进制转化成八进制字符串并返回。

print(oct(10),type(oct(10))) # 0o12 <class 'str'>

hex：将十进制转化成十六进制字符串并返回。

print(hex(10),type(hex(10))) # 0xa <class 'str'>

divmod：计算除数与被除数的结果，
返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(7,2)) # (3, 1)

round：保留浮点数的小数位数，默认保留整数。

print(round(7/3,2)) # 2.33
print(round(7/3)) # 2
print(round(3.32567,3)) # 3.326

pow：求x ** y次幂。（三个参数为x**y的结果对z取余）

print(pow(2,3)) # 两个参数为2**3次幂
print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。

ord : 输入字符找该字符编码的位置(在unicode内查找位置)

# ord 输入字符找该字符编码的位置
print(ord('a'))
print(ord('中'))

chr : 输入位置数字找出其对应的字符(在unicode内查找位置)

# chr 输入位置数字找出其对应的字符
print(chr(97))
print(chr(20013))

repr:返回一个对象的string形式（原封不动）。

# %r 原封不动的写出来
name = 'taibai'
print('我叫%r'%name)
---------------------------------
print(repr('{"name":"alex"}'))
print('{"name":"alex"}')

all：可迭代对象中，全都是True才是True

# all 可迭代对象中，全都是True才是True
print(all([1,2,True,0]))

any：可迭代对象中，有一个True 就是True

# any 可迭代对象中，有一个True 就是True
print(any([1,'',0]))

匿名函数

只能构建简单的函数,一句话函数

def func(x,y):
return x+y
print(func(1,2))
---------------------------------
func2=lambda x,y:x+y
print(func2(1,2))

装饰器

闭包

闭包形成的先决条件

闭包存在于嵌套函数中

内层函数对外层函数非全局变量引用(改变)

函数名逐层韩慧直至返回到最外层

闭包函数的特性

闭包函数的空间不会随着函数的结束而消失
(被引用的可变数据类型不会消失)

判断一个函数是不是一个闭包

def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total/len(series)
return averager
avg = make_averager()
# 函数名.__code__.co_freevars 查看函数的自由变量
print(avg.__code__.co_freevars) # ('series',)

闭包的应用

保证数据的安全,可以保存一些非全局变量但是不易被销毁、改变的数据。

装饰器的本质就是闭包

开放封闭原则

开放原则

在源码尽量不改变的情况下,更新增加一些额外的功能.

封闭原则

不要改变源码和调用方式

初识装饰器

装饰器是以功能为导向的,就是一个函数,
在不改变原被装饰的函数的源代码以及调用方式下,为其添加额外的功能.

python中装饰器 : 完美的诠释开放封闭原则

装饰器就是一个函数 : 他要装饰一个函数,
在不改变原函数的源码以及调用方式的前提下,
给其增加一个额外的功能

被装饰函数带返回值

明确源代码的返回值应该返回给谁

实际返回给了谁

如何修改

被装饰函数带参数的装饰器

明确源代码的传参应该传参给谁

实际传参给了谁

如何修改

标准版装饰器

代码优化

语法糖,Python给我们提供了一个简化机制,
用一个很简单的符号去代替类似home = timer(home)这一句话

def timer(func): # func = home
def inner(*args,**kwargs):
start_time = time.time()
func(*args,**kwargs)
end_time = time.time()
return inner
@timer # 此处代替了home = timer(home)
def home(name,age):
time.sleep(3) # 模拟一下网络延迟以及代码的效率
print(name,age)
print(f'欢迎访问{name}主页')
home('岁月',18)

注意

因为涉及函数的调用,@timer一定要放在被装饰函数的上方,否则会报错.

模块

模块分类

内置模块,标准库python解释器自带的有200多种

第三方库(模块),各种大神些的一些模块,通过pip install...安装,6000种

自定义模块,我们自己在项目中定义的一些模块

# 定义一个模块，定义一个模块其实很简单就是写一个文件
print('from the tbjx.py')
name = '张三丰'
def read1():
print('tbjx模块：',name)
def read2():
print('tbjx模块')
read1()
def change():
global name
name = 'barry'

import

import(导入的意思),模块可以包含可执行的语句和函数的定义，
这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行

import语句是可以在程序中的任意位置使用的,且针对同一个模块,为了防止你重复导入，
python的优化手段是：第一次导入后就将模块名加载到内存了，
后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句

第一次导入模块发生的三件事

将tbjx.py文件加载到内存

在内存中创建一个以tbjx命名的名称空间

通过tbjx名称空间的名字,等方式引用此模块的名字
(变量,函数名,类名等等)

被导入模块有独立的名称空间

每个模块都是一个独立的名称空间，
定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，
这样我们在编写自己的模块时，
就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突

# 模块名字 lern.py 模块内如下信息
print("乾坤")
name="张三丰"
---------------------------------
import lern # 执行结果乾坤
name="张无忌"
print(lern.name) # 打印结果张三丰

为模块起别名

将一个比较长的模块名化简成简单的

import tbjx as t
t.read1()

有利于代码的扩展和优化

#mysql.py 模块内的内容如下
def sqlparse():
print('from mysql sqlparse')
#oracle.py模块内的内容如下
def sqlparse():
print('from oracle sqlparse')
---------------------------------
#test.py 执行文件
db_type=input('>>: ')
if db_type == 'mysql':
import mysql as db
elif db_type == 'oracle':
import oracle as db
db.sqlparse()

导入多个模块

我们以后再开发过程中，免不了会在一个文件中，导入多个模块，

import os,sys,json # 这样写可以但是不推荐
---------------------------------
# 推荐写法
import os
import sys
import json

from...import...

form...import...的使用

# 模块名字 lern.py 模块内如下信息
print("乾坤")
name="张三丰"
def read1():
print("丐帮")
---------------------------------
# from ... import ... 的使用示例。
from lern import name, read1 # 执行结果乾坤
print(name) # 张三丰
read1() # 丐帮

form...import...与import对比

唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，
所以在当前名称空间中，直接使用名字就可以了、无需加前缀

优缺点

优点

使用起来方便了

缺点

容易与当前执行文件中的名字冲突

注意1

执行文件有与模块同名的变量或者函数名,
会有覆盖效果

# 模块名字 lern.py 模块内如下信息
name = '武当'
def read1():
print('tbjx模块：',name)
def read2():
return read1()
def change():
global name
name = 'barry'
---------------------------------
name = 'oldboy'
from lern import name, read1, read2
print(name) # 武当
---------------------------------
from lern import name, read1, read2
name = 'oldboy'
print(name) # oldboy
---------------------------------
def read1():
print(666)
from lern import name, read1, read2
read1() # tbjx模块：武当
---------------------------------
from lern import name, read1, read2
def read1():
print(666)
read1() # 666

注意2

当前位置直接使用read1和read2就好了,
执行时,仍然以lern.py文件全局名称空间

# 模块名字 lern.py 模块内如下信息
name = '武当'
def read1():
print('tbjx模块：',name)
def read2():
return read1()
def change():
global name
name = 'barry'
---------------------------------
from lern import read1
name = 'alex'
read1() # tbjx模块：武当
---------------------------------
from lern import read2
def read1():
print('==========')
read2() # tbjx模块：武当
---------------------------------
# 同时通过这种方式引用的模块也可以对模块进行改名。
from tbjx import read1 as read
read()

form...import*

from spam import * 把tbjx中所有的不是以下划线(_)开头的名字都导入到当前位置

大部分情况下我们的python程序不应该使用这种导入方式，
因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。
而且可读性极其的差，在交互式环境中导入时没有问题。

可以使用__ all __来控制（用来发布新版本），在lern.py中新增一行

一行导入多个

from tbjx import read1,read2,name

py文件的两种功能

编写好的一个python文件可以有两种用途

脚本,一个文件就是整个程序,用来被执行（比如模拟博客园的登录)

模块,文件中存放着一堆功能,用来被导入使用

python为我们内置了全局变量__ name __

当文件被当做脚本执行时：__ name __ 等于__ main __

当文件被当做模块导入时：__ name __等于模块名

模块的搜索路径

意义

当你引用一个模块时，
不见得每次都可以import到,
因此需要搜索路径

Python中引用模块是按照一定的规则以及顺序去寻找的，
这个查询顺序为：先从内存中已经加载的模块进行寻找找不到再从内置模块中寻找，
内置模块如果也没有，最后去sys.path中路径包含的模块中寻找。
它只会按照这个顺序从这些指定的地方去寻找，如果最终都没有找到，那么就会报错。

内存中已经加载的模块->内置模块->sys.path路径中包含的模块

模块的查找顺序

在第一次导入某个模块时（比如lern），
会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），
如果有则直接引用（ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看）

如果没有，解释器则会查找同名的内置模块

如果还没有找到就从sys.path给出的目录列表中依次寻找lern.py文件

注意

我们自定义的模块名不应该与系统内置模块重名

规范化开发

代码全部存放在一个一个py文件中弊端

文件加载问题

代码可读性,查询差

要将一个py文件分开,合理的分成多个py文件

配置文件放在一起

一些轻易不改变的变量,一般命名 settings.py

主逻辑函数放在一起

一般命名 src.py

辅助功能函数放在一起

公共组件部分,装饰器,log日志,一般命名 common.py

程序启动开关

放在明显位置,便于开启程序,一般命名 starts.py

数据库文件

register文件,文本数据库

日志

子主题

文件夹命名规范

bin

文件夹放启动文件

conf

放配置文件

core

放核心文件主逻辑

lib

放公共组件文件

放数据库文件

log

放日志文件

外加一个使用说明

README,此为文件

计算机

计算机基础

cpu

相当于人类的大脑,运算和处理问题

内存

临时存储数据,4G,8G,16G,32G

硬盘

永久存储数据

操作系统

实际上是管理计算机内存的分配,简单来讲操作系统是一个程序,控制每一个硬件之间的数据交互.

编程语言

编译型语言

优点

代码进行优化,只编译一次，程序执行效率高,可以脱离语言环境独立运行

缺点

编译之后如果需要修改就需要整个模块重新编译,操作系统之间一直会有问题.根据操作系统编译不同的可执行文件

解释型语言

优点

子主题

缺点

每次运行的时候都要解释一遍，性能上不如编译型语言

静态语言

动态语言

强类型定义语言

弱类型定义语言

编译器与解释器

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样计算机运行速度很快

解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快

Python介绍

历史

创始人

吉多.范罗苏姆(龟哥)

1989年，为了打发圣诞节假期，Guido(龟叔)开始写Python语言的编译器

理想：创造一种C和shell之间，功能全面，易学易懂，可拓展的语言

发展历程

1991年,Python编译器诞生

用C语言实现，并能够调用C语言的库文件

1994年,Python 1.0

增加了 lambda, map, filter and reduce.

2000年,Python 2.0

优点

加入了内存回收机制，构成了现在Python语言框架的基础

缺点

功能重复,维护难度大

2004年,Django框架

Django框架,使用方便,应用至今

2008年,Python 3.0

源码统一,没有重复代码(功能),维护难度降低

Python语言类型

Python是一门动态解释性的强类型定义语言

Python语言优缺点

优点

优雅,明确,简单

开发效率非常高

Python有非常强大的第三类库,可以直接调用,降低开发周期

高级语言

无需考虑一些底层的细节

可移植性

由于它的开源本质,几乎可以在所有的平台运行

可扩展性

你可以把你的部分程序用C或C++编写

可嵌入性

可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能

缺点

速度慢

代码不能加密

线程不能利用多CPU问题

Python解释器种类

CPython

C语言开发的，CPython是使用最广的Python解释器

IPython

IPython是基于CPython之上的一个交互式解释器,cmd中提示符不同

Jython

Python的Java实现，Jython会将Python代码动态编译成Java字节码，然后在JVM上运行

IronPython

Python的C#实现，IronPython将Python代码编译成C#字节码，然后在CLR上运行。（与Jython类似）

PyPy

将Python的字节码字节码再编译成机器码,动态编译,开发快,运行快

应用领域

云计算

云计算最火的语言，典型应用OpenStack

WEB开发

众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣,典型WEB框架有Django

科学运算

典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas

系统运维

运维人员必备语言

爬虫

通过代码来模拟人类访问网页,选择有用信息进行下载

金融

量化交易，金融分析,作为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定

图像GUI

PyQT, WxPython,TkInter

Python在一些公司的应用

谷歌

Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、
Google广告等项目都在大量使用Python开发

NASA

美国航天局(NASA)大量使用Python进行数据分析和运算

YouTube

世界上最大的视频网站YouTube就是用Python开发的

CIA

美国中情局网站就是用Python开发的

Facebook

大量的基础库均通过Python实现的

豆瓣

公司几乎所有的业务均是通过Python开发的

 收藏

立即使用

计算机语言学习

檀缱

职业：暂无

去主页





0 条评论

下一页

为你推荐

查看更多



python050-django学生宿舍管理系统