python成长之路——第二天

Posted 2020-07-20

cpython：c解释器  .pyc（字节码）——机器码

jpython ：java解释器   java字节码  

ironpython ：C#解释器   C#字节码  

。。。。

上面的：编译完之后是字节码   

pypy：自己的解释器  自己的字节码   机器码  编译完直接是机器码  直接运行机器码  快 类似java

 

《python源码剖析》

 

编码：

#-*- coding: utf-8 -*-

 

8位：2**8=256——Unicode（万国码）至少16位——utf-8：Unicode的压缩（不同类型的位数不同）

utf-8：ascii：数字，字母，字符——8位

            欧洲：2个字节

            汉字：3个字节

 

单行注释：单引号

多行注释：双引号

 

python执行时会优先找字节码

python里有缓冲池，内存里会维护一段内存空间池用来缓存常用数据

 

数据类型：

 

|万恶的连接符（+）：每次连接都会开辟一个新的内存空间（原内存空间程序不会删除，解释器有回收机制，发现没有人调用此内存空间即会回收）

eg：a=b+c+d 会开辟3个内存空间

|字符串格式化   ：

 

python是有主文件的

 

对于python，一切事物都是对象，对象基于类（class）创建，相同类型的对象是由同一个类创建的，这些对象的功能是相同的，其功能集存放在创建这个对象的类里

 

 

s = "dd"

s = str(‘dd‘)

l1 = [1,2,3]

l1 = list("1,2,3")

 

都是先创建对象——再调用方法

 

（1）int：

   __abs__      abs

   __add__      +

   __divmod__    产生商和余数  用于分页    __rdivmod__  加上r代表被除数和除数进行替换

   __eq__

   __ge__

   __gt__

 

python里的源码包括：C写的源码和python写的源码 所以在看python源码时看到方法下面没写代码，写的是pass

 

（2）str：

 type(对象名)  对象的类

dir(对象名)     对象的类和类的成员

 

__contains__   包含 等价于 in

>>> ("zhangyan").__contains__("yan")

True

>>> "yan" in "zhangyan"

True

 

capitalize      首字母小写转大写

>>> ("admin").capitalize()

‘Admin‘

 

casefold        所有字母大写转小写

 

center(num,填充字符串)   字符居中  num是长度  

>>> ("admin").center(20,‘-‘)

‘-------admin--------‘

 

count(要统计字符,从第几个字符开始,到第几个字符结束)  统计字符出现次数

>>> ("asdfgfdertyeru").count("f",0,9)

2

 

encode(‘gbk‘)  编码成gbk

 

endswith(结尾字符,从第几个字符开始,到第几个字符结束) 判断是否以某字符串结尾

   

expandtabs()  把tab键（\t）转换为8个空格

 

find(字符) 查找字符   找不到返回-1

index(字符) 查找字符  找不到会报错

 

format  字符串拼接  同+ 同格式化字符串

>>> name="{0} like {1}"

>>> result=name.format("zhangjie","zhangyan")

>>> result

‘zhangjie like zhangyan‘

 

‘分隔符‘.join(要拼接的字符)  用来做拼接

 

partition(分割标志字符串)  分割字符串

 

replice(‘a‘,‘c‘) a全转换成c

 

rjust   右对齐

split    指定字符分割字符串

 

with  连接上下文

元组（tuple）：

元组最后一个元素要加，

count

index

 

字典（dict）

dic1 = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}

dic1 = dict(k1=‘v1‘,k2=‘v2‘)

 

dic1.get(‘k1‘)   同dic1(‘k1‘)  不同的是如果key不存在 后者会报错，前者会返回null

 

格式符

格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:

%s    字符串 (采用str()的显示)

%r    字符串 (采用repr()的显示)

%c    单个字符

%b    二进制整数

%d    十进制整数

%i    十进制整数

%o    八进制整数

%x    十六进制整数

%e    指数 (基底写为e)

%E    指数 (基底写为E)

%f    浮点数

%F    浮点数，与上相同

%g    指数(e)或浮点数 (根据显示长度)

%G    指数(E)或浮点数 (根据显示长度)

 

%%    字符"%"

 

可以用如下的方式，对格式进行进一步的控制：

%[(name)][flags][width].[precision]typecode

(name)为命名

flags可以有+,-,‘ ‘或0。+表示右对齐。-表示左对齐。‘ ‘为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。

width表示显示宽度

precision表示小数点后精度

 

全局变量使用

总结：

1. 内部函数，不修改全局变量可以访问全局变量
2. 内部函数，修改同名全局变量，则python会认为它是一个局部变量
3. 在内部函数修改同名全局变量之前调用变量名称（如print sum），则引发Unbound-LocalError

在程序中设置的sum属于全局变量,而在函数中没有sum的定义,根据python访问局部变量和全局变量的规则：当搜索一个变量的时候，python先从局部作用域开始搜索，如果在局部作用域没有找到那个变量，那样python就在全局变量中找这个变量，如果找不到抛出异常(NAMEERROR或者Unbound-LocalError，这取决于python版本。)

如果内部函数有引用外部函数的同名变量或者全局变量,并且对这个变量有修改.那么python会认为它是一个局部变量,又因为函数中没有sum的定义和赋值，所以报错。

 

遇到在程序中访问全局变量并且要修改全局变量的值的情况可以使用：global关键字，在函数中声明此变量是全局变量

eg：

if __name__ == ‘__main__‘:
    bal=0                             #我的钱（自己定义）
settle_accounts()

def settle_accounts():
global bal
global money
if bal > money:
        bal-=money
print "恭喜您购买成功！您的消费为：%d 您的余额为：%d" % (money,balance)

 字符串，元组，列表，字典之间的相互转换

#1、字典

dict = {‘name‘: ‘Zara‘, ‘age‘: 7, ‘class‘: ‘First‘}

 

#字典转为字符串，返回：<type ‘str‘> {‘age‘: 7, ‘name‘: ‘Zara‘, ‘class‘: ‘First‘}

print type(str(dict)), str(dict)

 

#字典可以转为元组，返回：(‘age‘, ‘name‘, ‘class‘)

print tuple(dict)

#字典可以转为元组，返回：(7, ‘Zara‘, ‘First‘)

print tuple(dict.values())

 

#字典转为列表，返回：[‘age‘, ‘name‘, ‘class‘]

print list(dict)

#字典转为列表

print dict.values

 

#2、元组

tup=(1, 2, 3, 4, 5)

 

#元组转为字符串，返回：(1, 2, 3, 4, 5)

print tup.__str__()

 

#元组转为列表，返回：[1, 2, 3, 4, 5]

print list(tup)

#元组不可以转为字典

 

#3、列表

nums=[1, 3, 5, 7, 8, 13, 20];

 

#列表转为字符串，返回：[1, 3, 5, 7, 8, 13, 20]

print str(nums)

 

#列表转为元组，返回：(1, 3, 5, 7, 8, 13, 20)

print tuple(nums)

 

#列表不可以转为字典

 

#4、字符串

 

#字符串转为元组，返回：(1, 2, 3)

print tuple(eval("(1,2,3)"))

#字符串转为列表，返回：[1, 2, 3]

print list(eval("(1,2,3)"))

#字符串转为字典，返回：<type ‘dict‘>

print type(eval("{‘name‘:‘ljq‘, ‘age‘:24}"))

 

open/文件操作

f=open(‘/tmp/hello‘,‘w‘)

#open(路径+文件名,读写模式)

#读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式

如:‘rb‘,‘wb‘,‘r+b‘等等

读写模式的类型有：

rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w     以写方式打开，
a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+     以读写模式打开
w+     以读写模式打开 (参见 w )
a+     以读写模式打开 (参见 a )
rb     以二进制读模式打开
wb     以二进制写模式打开 (参见 w )
ab     以二进制追加模式打开 (参见 a )
rb+    以二进制读写模式打开 (参见 r+ )
wb+    以二进制读写模式打开 (参见 w+ )
ab+    以二进制读写模式打开 (参见 a+ )

注意：

1、使用‘W‘，文件若存在，首先要清空，然后（重新）创建，

2、使用‘a‘模式 ，把所有要写入文件的数据都追加到文件的末尾，即使你使用了seek（）指向文件的其他地方，如果文件不存在，将自动被创建。

f.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)

file.readline() 返回一行

file.readline([size]) 返回包含size行的列表,size 未指定则返回全部行

for line in f: print line #通过迭代器访问

f.write("hello\n") #如果要写入字符串以外的数据,先将他转换为字符串.

f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).

f.seek(偏移量,[起始位置])

用来移动文件指针

偏移量:单位:比特,可正可负

起始位置:0-文件头,默认值;1-当前位置;2-文件尾

f.close() 关闭文件

Code:

#!/usr/bin/env python
# Filename: using_file.py

poem=‘‘‘\Programming is funWhen the work is doneif you wanna make your work also fun: use Python!‘‘‘
f=file(‘poem.txt‘,‘w‘) # open for ‘w‘riting
f.write(poem) # write text to file
f.close() # close the file
f=file(‘poem.txt‘)

# if no mode is specified, ‘r‘ead mode is assumed by default
while True: 
line=f.readline() 
if len(line)==0: # Zero length indicates EOF 
break 
print line, 
# Notice comma to avoid automatic newline added by Python
f.close() 
# close the file