计算机语言学习
2019-10-15 10:06:26 0 举报AI智能生成
python基础学习
作者其他创作
大纲/内容
Python学习
打印方式
print() 打印
print(\
变量
变量的作用
变量的运行过程
a=1
起了一个变量名 : a
有一个值 : 1
将值赋给变量名 : =
定义变量的规则
不能以数字开头
区分大小写
不要用中文或拼音
命名要有意义
不能用Python关键字命名
推荐使用驼峰或下划线的方式命名
常量
注释
作用
使用方式
单行注释
多行注释
'''注释内容'''
Python基础数据类型初识
整型
十进制二进制
在python3中所有的整数都是int类型. 但在python2中如果数据量比较大. 会使用long类型.但是在python3中不存在long类型
操作
bit_length(). 计算整数在内存中占用的二进制码的长度
可进行 + - * / 运算 int 表示
字符串
深入了解
字符串+索引及其操作方法
操作方法
索引取值
实例
s1 = \"python学习\
切片
s2 = \"python好学习\
语法
str[start:end]
start
起始位置
end
结束位置
规则
用法
我们可以使用下标来截取部分字符串的内容
步长
str[start : end : step]
step
字符串的表现形式
索引
认识
字符串的常用方法
注意
大小写互相转换
常应用于校验用户输入的验证码是否合法
字符串的切割
# 居中s = \"周杰伦\
字符串的查找
s = \
is 系列
计算字符串的长度
s = \"你好我是***\"ret = len(s) # 计算字符串的长度度print(ret) # 打印结果为7# len()是python的内置函数
定义
拼接方式
布尔值
布尔值深入了解
Ture:真
False:假
运算符简单认识
算数运算
假设变量：a=10，b=20
+
-
*
/
%
**
//
赋值运算
=
+=
-=
*=
/=
**=
%=
//=
比较运算
>
<
==
<=
>=
!=
逻辑运算
优先级关系
在没有()的情况下not 优先级高于 and，and优先级高于or即优先级关系为( )>not>and>or，同一优先级从左往右计算
子主题
and
or
not
成员运算
c=\"abcdefg\"print(\"a\" in c)#输出结果为Tureprint(\"h\"not in c)#输出结果为Ture
in
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(\"打印要求\")else:#当if不成立时是执行. print(\"打印要求\")#当else成立时执行操作.
多个选项进行单选
num = 1if num == 1: print('打印要求')elif num == 2: print('打印要求')elif num == 3: print('打印要求')else: print(\"打印要求\")#当num不满足以上条件要求时else才成立
多个选项进行多选
num = 1if num == 1: print('打印要求')if num == 2: print('打印要求')if num == 3: print('打印要求')#此判断可以进行多个判断进行多个选择.#与单选判断的区别是单选判断时当满足一个条件要求后不再判断其它的条件.
if 嵌套
字符串的格式化
意义
按照既定的要求进行有规定排版的一种输出方式
非占位符方式
#我们想要输出的格式如下:-----------------------------name:小明age:15hobby:篮球----------------------------- #为了达到以上目的需要进行格式化输出name=input(\"name:\")age=input(\"age:\")hobby=input(\"hobby:\")print(\"-----------------------------\
占位符方式
占位符简单解释
主要用于格式化输出
Python初期%衔接的常用数据类型
#我们想要输出的格式如下:-----------------------------name:小明age:15hobby:篮球----------------------------- #这次我们用占位符的帮助来完成看是否变的便利name=input(\"name:\")age=int(input(\"age:\"))#当占位符是%d的时候需要将其转化为整数在嵌入到占位位置hobby=input(\"hobby:\
%s 用str()进行转化后填充至占位符位置(%s也称为任意占位符)
注意事项
f '''{}''' 方式
介绍
适用范围
python3.6之后的版本可用
#我们想要输出的格式如下:-----------------------------name:小明age:15hobby:篮球-----------------------------#这次我们用f '''{}'''的帮助来完成看是否变的更加便利print(f'''-----------------------------name:{input(\"name:\")}age:{input(\"age:\")}hobby:{input(\"hobby:\")}-----------------------------''')#根据情况来灵活运用没有最好的方法只有最对的.
while循环
简介
while本身相关关键字
break
作用是终止当前while所属循环层
continue
else
当while循环正常结束后执行此操作
初识编码
常见编码
ASCII
GBK
Unicode
UTF-8
单位转化
- 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用法
for i in range(5) print(i)#打印结果从0到4
列表
优点
列表索引
列表与字符串一样也有索引
# 列表索引的应用lst = [\"asd\
列表切片
列表与字符串一样可进行切片操作
lst = [\"asd\
列表的操作
分为五种
增
# 在列表后新增lst = [\"asd\
删
# pop删除用法lst = [\"asd\
改
# 列表的修改lst = [\"asd\
查
列表是一个可以迭代的对象
# 用for查询打印列表每一个元素lst = [\"asd\
其它
列表嵌套
lst = [\"武当\
元组
元组的操作
# 元组取值和切片tup = (\"asd\
字典初识
字典进阶
字典的操作
dic = {}dic[\"name\
# pop删除 # 会有返回值ret = dic.pop(\"jay\")print(ret)---------------------------------# del删除del dic[\"jay\"]print(dic)---------------------------------# 随机删除.ret = dic.popitem()---------------------------------# 清空字典中的所有内容dic.clear()
# 通过key值查询dic = {\"武当\":\"太极\
dic = {\"武当\":\"太极\
字典嵌套
字典总结
小数据池
什么是小数据池
小数据池 is和==的区别
== 判断等号俩边的值是否相同is 判断两个内存地址是否相同
小数据池和代码块的关系
集合
集合介绍
集合操作
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([\"武当\
深浅拷贝
深拷贝
import copylst1 = [\"张三丰\
浅拷贝
lst1 = [\"张三丰\
数据类型深入了解
数据类型转换
数据类型操作注意事项
文件操作
文件操作进阶
文件操作方式
r w a 操作的都是文本
rd r+d wb w+bab 操作非文本文件
f = open(\"1.jpg\
import requestsret=requests.get(\"http://www.521609.com/uploads/allimg/151124/1-1511241G251317.png\")f = open(\"2.jpg\
其它方式
偏移量
位置
文件路径分类
绝对路径
从磁盘的跟处查找
相对路径
import osprint(os.getcwd()) # 查看当前工作路径
文件安全读取方式
f=open(\"文件\
打开文件的方式(第二种)
- 此方式系统会自动帮助关闭文件- 可以同时操作多个文件- 可以同时操作一个文件.
with open(\"文件路径1\
lis=[]num=1with open(\"a1\
基本操作
1. 打开文件 open2. 操作文件 read or write3. 关闭文件 close
# 不使用r时f=open(\"D:\\\\Git\\\\Git存储\\\\学习.txt\
函数
函数进阶
函数传参
目的
函数可扩展性
传参分类
实参角度
位置参数
关键字参数
混合参数
形参角度
形参角度的最终顺序
- *args不能放在位置参数前面- *args不能放在默认参数后面- **kwargs不能放在默认参数前面
位置参数
与实参角度位置参数一致
默认参数
动态参数(万能参数)
正常用法
特殊用法
函数内
# 函数内*用法def func(*args): # *args这里是一个元组 print(args)lis1=[\"少林\
函数外
仅限关键字参数(了解即可)
从空间角度研究函数
取值顺序加载顺序
加载顺序
内置名称空间>>全局名称空间>>(当函数执行时)局部名称空间
取值顺序
全局名称(命名)空间
临时(局部)名称空间
内置名称空间
全局作用域
全局名称空间+内置名称空间
局部作用域
局部名称空间
globals()
以字典的形式返回全局作用域所有的变量对应关系
locals()
以字典的形式返回当前作用域的变量的对应关系
高阶函数(嵌套函数)
例子1
# 实例1：def func1(): print('in func1') print(3)def func2(): print('in func2') print(4)func1() # in func1 3print(1) # 1func2() # in func2 4print(2) # 2
例子2
# 例2：def func1(): print('in func1') print(3)def func2(): print('in func2') func1() print(4)print(1) # 1func2() # in func2 in func1 3 4print(2) # 2
例子3
# 例3：def fun2(): print(2) def fun3(): print(6) print(4) fun3() print(8)print(3) # 3fun2() # 2 4 6 8print(5) # 5
关键字：global、nonlocal
global
作用1
声明一个全局变量。
# global第一个功能：在局部作用域中可以更改全局作用域的变量count = 1def search(): global count count = 2search()print(count) # 2
作用2
在局部作用域想要对全局作用域的全局变量进行修改时，需要用到 global(限于字符串，数字)
# global第二个功能：利用global在局部作用域也可以声明一个全局变量。def func(): global a a = 3func()print(a) # 3
nonlocal
def add_b(): b = 42 def do_global(): b = 10print(b) def dd_nonlocal(): nonlocal b b = b + 20 print(b) dd_nonlocal() print(b) do_global() print(b)add_b()
默认函数注意事项
函数名的应用
def func(args): return argsprint(func) # <function func at 0x00000000024656A8>print(func(1)) # 1
函数名是一个变量
def age1(a): return aage2=age1age3=age2print(age3(1)) # 1
函数名可以作为容器类类型的元素
def func1(): print(\"in func1\")def func2(): print(\"in func2\")def func3(): print(\"in func3\
函数名可以作为函数的实参进行传参
def func(argv): print(argv)def func1(): print(\"in func1\")def func2(argv): argv() print(\"in func2\")a=1func(a) # 1 func2(func1) # in func1# in func2
函数名可以作为函数的返回值
def func1(): print(\"in func1\")def func2(argv): print(\"in func2\") return argvret=func2(func1)print(ret) # in func2# <function func1 at 0x0000000001DF56A8>
函数初识
函数结构
函数调用
函数的返回值
return
给函数的执行者返回具体的值（三种情况）
迭代器
迭代器进阶
例子
先要将可迭代对象转化成迭代器
利用next()对迭代器进行取值
可迭代对象与迭代器对比
字面意思分析
专业角度分析
缺点
可以重复迭代的工具
专业角度分析
生成器
生成器进阶
yield与return的区别
send和next()区别
# next只能获取yield生成的值，但是不能传递值。def gen(name): print(f'{name} ready to eat') while 1: food = yield print(f'{name} start to eat {food}')---------------------------------dog = gen('alex')next(dog)next(dog)next(dog)---------------------------------# 而使用send这个方法是可以的。def gen(name): print(f'{name} ready to eat') while 1: food = yield 222 print(f'{name} start to eat {food}')---------------------------------dog = gen('alex')next(dog) # 第一次必须用next让指针停留在第一个yield后面# 与next一样，可以获取到yield的值ret = dog.send('骨头')print(ret)---------------------------------def gen(name): print(f'{name} ready to eat') while 1: food = yield print(f'{name} start to eat {food}')---------------------------------dog = gen('alex')next(dog)# 还可以给上一个yield发送值dog.send('骨头')dog.send('狗粮')dog.send('香肠')
相同点
不同点
yiled与yiled from
生成器初始
生成器产生方式
生成器函数
生成器表达式
列表推导式与生成器表达式
列表推导式
一行代码构建一个有规律比较复杂的列表
循环模式
[变量(加工后的变量) for 变量 in iterable]
筛选模式
[变量(加工后的变量) for 变量 in iterable if 条件]
列表推导式的优缺点
触发生成器(迭代器)取值方式
next(生成器)
for 内部用next(生成器)
list(生成器)
内置函数
内置函数进阶
print() 屏幕输出
int() : 在此不过多说明
str() : 在此不过多说明
bool() : 在此不过多说明
set() : 在此不过多说明
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
dict() 通过相应的方式创建字典
abs() 返回绝对值
i = -5print(abs(i)) # 5
sum() 求和
min() 求最小值
max() 最大值与最小值用法相同
bytes() 把字符串转换成bytes类型
sorted排序函数
filter筛选过滤
map映射函数
reduce
eval：执行字符串类型的代码(解开并返回最终结果)
eval('2 + 2') # 4n=81eval(\"n + 4\") # 85eval('print(666)') # 666
exec:执行字符串类型的代码(只解开没有返回值)
hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
help：函数用于查看函数或模块用途的详细说明。
print(help(list))print(help(str.split))
callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
name = 'alex'def func(): passprint(callable(name)) # Falseprint(callable(func)) # True
int：函数用于将一个字符串或数字转换为整型。
float：函数用于将整数和字符串转换成浮点数。
print(float(3)) # 3.0
complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
bin：将十进制转换成二进制并返回。
oct：将十进制转化成八进制字符串并返回。
hex：将十进制转化成十六进制字符串并返回。
round：保留浮点数的小数位数，默认保留整数。
pow：求x ** y次幂。（三个参数为x**y的结果对z取余）
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
any：可迭代对象中，有一个True 就是True
匿名函数
装饰器
装饰器进阶
带参数的装饰器
@wrapper_out(\"qq\")此时分两步执行
def user_information(n): user_name = input(\"账号:\").strip() user_password = input(\"密码:\
第一步先执行wrapper_out(\"qq\")函数，得到返回值wrapper
第二步@与wrapper结合，形成装饰器@wrapper 然后在依次执行
多个装饰器装饰一个函数
递归函数
函数表达式样式
def func(): print(\"太极\") func()func()
闭包
闭包形成的先决条件
闭包存在于嵌套函数中
内层函数对外层函数非全局变量引用(改变)
函数名逐层韩慧直至返回到最外层
闭包函数的特性
闭包函数的空间不会随着函数的结束而消失(被引用的可变数据类型不会消失)
判断一个函数是不是一个闭包
闭包的应用
装饰器的本质就是闭包
开放封闭原则
开放原则
封闭原则
不要改变源码和调用方式
初识装饰器
python中装饰器 : 完美的诠释开放封闭原则
被装饰函数带返回值
明确源代码的返回值应该返回给谁
实际返回给了谁
如何修改
被装饰函数带参数的装饰器
明确源代码的传参应该传参给谁
实际传参给了谁
标准版装饰器
标准装饰器
代码优化
模块
模块进阶
序列化模块(很重要)
序列化
我们现在要解决的问题
序列化模块
json与pickle模块
json模块
json序列化 两对四个方法
dumps与loads
主要用于网络传输
dump与load
单个数据的存取文件
json序列化存储多个数据到同一个文件中
pickle模块
pickle序列化 两对四个方法
只能是网络传输
dump与load
pickle序列化存储多个数据到一个文件中
os模块
单独学习
__ file __动态获取当前文件的绝对路径
当前执行这个python文件的工作目录相关的工作路径
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 ***os.chdir(\"dirname\") 改变当前脚本工作目录；相当于shell下cd **os.curdir 返回当前目录: ('.') **os.pardir 获取当前目录的父目录字符串名：('..') **
和文件夹相关
path与路径相关***
os.stat('path/filename') 获取文件/目录信息 的结构说明
stat 结构:st_mode: inode 保护模式st_ino: inode 节点号。st_dev: inode 驻留的设备。st_nlink: inode 的链接数。st_uid: 所有者的用户ID。st_gid: 所有者的组ID。st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。st_atime: 上次访问的时间。st_mtime: 最后一次修改的时间。st_ctime: 由操作系统报告的\"ctime\"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
sys模块
sys模块是与python解释器交互的一个接口
hashlib模块
hashlib的特征以及使用要点
bytes类型数据 ---> 通过hashlib算法 ---> 固定长度的字符串
不同的bytes类型数据转化成的结果一定不同。
相同的bytes类型数据转化成的结果一定相同。
此转化过程不可逆。
hashlib的主要用途有两个
密码的加密
MD5加密
正常加密
我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：
import hashlibmd5 = hashlib.md5()md5.update('123456'.encode('utf-8'))print(md5.hexdigest())# 计算结果如下：'e10adc3949ba59abbe56e057f20f883e'# 验证：相同的bytes数据转化的结果一定相同import hashlibmd5 = hashlib.md5()md5.update('123456'.encode('utf-8'))print(md5.hexdigest())# 计算结果如下：'e10adc3949ba59abbe56e057f20f883e'# 验证：不相同的bytes数据转化的结果一定不相同import hashlibmd5 = hashlib.md5()md5.update('12345'.encode('utf-8'))print(md5.hexdigest())# 计算结果如下：'827ccb0eea8a706c4c34a16891f84e7b'
加盐加密
固定的盐
ret = hashlib.md5('xx流派'.encode('utf-8')) # xx流派就是固定的盐ret.update('a'.encode('utf-8'))print(ret.hexdigest())
动态的盐
username = '九阴真经'ret = hashlib.md5(username[::2].encode('utf-8')) # 针对于每个账户，每个账户的盐都不一样ret.update('a'.encode('utf-8'))print(ret.hexdigest())
sha系列加密
#也可加盐ret = hashlib.sha384(b'asfdsa')ret.update('jiuyinzhenjing'.encode('utf-8'))print(ret.hexdigest())
# 也可以加动态的盐ret = hashlib.sha384(b'asfdsa'[::2])ret.update('jiuyinzhenjing'.encode('utf-8'))print(ret.hexdigest())
文件一致性校验
time模块
与实践相关的模块三种形式
时间戳
格式化时间(人类看得懂的时间)
2019-6-28 12:00
%y 两位数的年份表示（00-99）%Y 四位数的年份表示（000-9999）%m 月份（01-12）%d 月内中的一天（0-31）%H 24小时制小时数（0-23）%I 12小时制小时数（01-12）%M 分钟数（00=59）%S 秒（00-59）%a 本地简化星期名称%A 本地完整星期名称%b 本地简化的月份名称%B 本地完整的月份名称%c 本地相应的日期表示和时间表示%j 年内的一天（001-366）%p 本地A.M.或P.M.的等价符%U 一年中的星期数（00-53）星期天为星期的开始%w 星期（0-6），星期天为星期的开始%W 一年中的星期数（00-53）星期一为星期的开始%x 本地相应的日期表示%X 本地相应的时间表示%Z 当前时区的名称%% %号本身python中时间日期格式化符号：
元组(struct_time)
struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
python中表示时间的几种格式
#导入时间模块>>>import time#时间戳>>>time.time()1500875844.800804#时间字符串>>>time.strftime(\"%Y-%m-%d %X\")'2017-07-24 13:54:37'>>>time.strftime(\"%Y-%m-%d %H-%M-%S\
几种格式之间的转换
#结构化时间 --> %a %b %d %H:%M:%S %Y串#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串>>>time.asctime(time.localtime(1500000000))'Fri Jul 14 10:40:00 2017'>>>time.asctime()'Mon Jul 24 15:18:33 2017'#时间戳 --> %a %d %d %H:%M:%S %Y串#time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串>>>time.ctime()'Mon Jul 24 15:19:07 2017'>>>time.ctime(1500000000)'Fri Jul 14 10:40:00 2017' t = time.time()ft = time.ctime(t)print(ft)st = time.localtime()ft = time.asctime(st)print(ft)
计算时间差
datetime模块
random模块
模块分类
import
第一次导入模块发生的三件事
将tbjx.py文件加载到内存
在内存中创建一个以tbjx命名的名称空间
重复导入会直接引用内存中已经加载好的结果
被导入模块有独立的名称空间
每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突
# 模块名字 lern.py 模块内如下信息 print(\"乾坤\")name=\"张三丰\"---------------------------------import lern # 执行结果 乾坤name=\"张无忌\"print(lern.name) # 打印结果 张三丰
为模块起别名
将一个比较长的模块名化简成简单的
import tbjx as tt.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 dbelif db_type == 'oracle': import oracle as dbdb.sqlparse()
导入多个模块
我们以后再开发过程中，免不了会在一个文件中，导入多个模块，
from...import...
form...import...的使用
# 模块名字 lern.py 模块内如下信息 print(\"乾坤\")name=\"张三丰\"def read1(): print(\"丐帮\
form...import...与import对比
唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀
优缺点
使用起来方便了
容易与当前执行文件中的名字冲突
注意1
注意2
form...import*
from spam import * 把tbjx中所有的不是以下划线(_)开头的名字都导入到当前位置
大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。
可以使用__ all __来控制（用来发布新版本），在lern.py中新增一行
一行导入多个
py文件的两种功能
编写好的一个python文件可以有两种用途
python为我们内置了全局变量__ name __
当文件被当做脚本执行时：__ name __ 等于__ main __
当文件被当做模块导入时：__ name __等于模块名
用来控制.py文件在不同的应用场景下执行不同的逻辑（或者是在模块文件中测试代码）
模块的搜索路径
Python中引用模块是按照一定的规则以及顺序去寻找的，这个查询顺序为：先从内存中已经加载的模块进行寻找找不到再从内置模块中寻找，内置模块如果也没有，最后去sys.path中路径包含的模块中寻找。它只会按照这个顺序从这些指定的地方去寻找，如果最终都没有找到，那么就会报错。
内存中已经加载的模块->内置模块->sys.path路径中包含的模块
模块的查找顺序
在第一次导入某个模块时（比如lern），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用（ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看）
如果没有，解释器则会查找同名的内置模块
如果还没有找到就从sys.path给出的目录列表中依次寻找lern.py文件
我们自定义的模块名不应该与系统内置模块重名
规范化开发
代码全部存放在一个一个py文件中弊端
文件加载问题
配置文件放在一起
主逻辑函数放在一起
一般命名 src.py
辅助功能函数放在一起
程序启动开关
数据库文件
日志
文件夹命名规范
bin
文件夹放启动文件
conf
放配置文件
core
放核心文件 主逻辑
lib
放公共组件文件
db
放数据库文件
log
放日志文件
外加一个使用说明
计算机语言学习
计算机
计算机基础
cpu
内存
硬盘
永久存储数据
操作系统
编程语言
编译型语言
解释型语言
每次运行的时候都要解释一遍，性能上不如编译型语言
静态语言
动态语言
强类型定义语言
弱类型定义语言
编译器与解释器
Python介绍
历史
创始人
吉多.范罗苏姆(龟哥)
1989年，为了打发圣诞节假期，Guido(龟叔)开始写Python语言的编译器
理想：创造一种C和shell之间，功能全面，易学易懂，可拓展的语言
发展历程
用C语言实现，并能够调用C语言的库文件
加入了内存回收机制，构成了现在Python语言 框架的基础
Python语言类型
Python是一门动态解释性的强类型定义语言
Python语言优缺点
开发效率非常高
高级语言
无需考虑一些底层的细节
可移植性
可扩展性
你可以把你的部分程序用C或C++编写
可嵌入性
可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能
速度慢
代码不能加密
线程不能利用多CPU问题
Python解释器种类
CPython
C语言开发的，CPython是使用最广的Python解释器
IPython
Jython
Python的Java实现，Jython会将Python代码动态编译成Java字节码，然后在JVM上运行
IronPython
Python的C#实现，IronPython将Python代码编译成C#字节码，然后在CLR上运行。（与Jython类似）
PyPy
应用领域
云计算
云计算最火的语言， 典型应用OpenStack
WEB开发
科学运算
系统运维
运维人员必备语言
爬虫
金融
图像GUI
Python在一些公司的应用
谷歌
Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、Google广告等项目都在大量使用Python开发
NASA
美国航天局(NASA)大量使用Python进行数据分析和运算
YouTube
世界上最大的视频网站YouTube就是用Python开发的
CIA
美国中情局网站就是用Python开发的
Facebook
大量的基础库均通过Python实现的
豆瓣
公司几乎所有的业务均是通过Python开发的
0 条评论
回复 删除
下一页
