Python基础1
Python
Python 前端后端都能做 后端有优势并应用广泛linux自带python 类库齐全
但是 相比其他语言效率略差
python种类: 1.cpython 2.jython ironpython…. 3.pypy
但统一规则
cpython即python: python => 字节码 => 机器码 =>计算机
jython: python => java字节码 => java虚拟机 => ….
pypy: python => 机器码 =>计算机
python2.7 vs 3.0
1. 默认支持中文 2.x = 默认编码 =ASSIC =不支持 3.x = 默认编码 =UNICODE =默认支持中文
2. 不兼容2.x
3. 核心语法调整，更易学
4. 新特性默认只在3.x上有
字符编码:
二进制 —> Ascii —>gb2312 -->gbk1.0-->gb18030
二进制 —> Ascii -->unicode -->utf-8
支持中文的第一张表就叫 GB2312
1980 gb2312 6700+
1995 gbk1.0 20000
2000 gb18030 27000
big5 台湾繁体
unicode 万国码 支持所有国家和地区的编码
2**16 = 65535 = 存一个字符 统一占用4个字节
unicode: utf-32: 一个字符占4个字节
unicode: utf-16: 一个字符占2个字节或2个以上, 65535
unicode: utf-8: 一个英文ASCII码来保存, 一个中文占3字节
UTF-8 = unicode 的扩展集，可变长的字符编码集
UTF-8，是对Unicode编码的压缩和优化，他不再使用少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存
Python2.x == Ascii 默认编码
若要输出中文 需以下声明
#!-*- coding:utf-8 -*-或者#coding:utf-8
#!-*- coding:utf-8 -*-
print ”你好世界”
仍然乱码 因为windows的字符编码是gbk
且文本编辑器的字符编码也不是utf-8
所以方法:
#!-*- coding:utf-8 -*-
print u”你好世界”
因为 unicode 是向下兼容gb2312 , gbk
python3.x == unicode默认编码
编码解码:
GBK ——解码decode——> unicode <——编码encode—— JPK
编码encode: 把自己的语言转成unicode
解码decode: 把unicode转成自己的语言
In Py2:
默认是ASCII
s = ‘特斯拉'
s_to_unicode = s.decode(“utf-8”) #unicode和utf-8不兼容
unicode_to_gbk = s_to_unicode.encode(“gbk”) #unicode是向下兼容gbk 所以即使没用encode也不会出错
In Py3:
默认编码是unicode
encode 在编码的同时, 会把数据转成bytes类型
decode 在解码的同时, 会把bytes类型转成字符串
b = byte = 字节类型 = [0 - 255]
Python3只有两种str和bytes, 其默认编码是unicode
str -> unicode, bytes -> 字节码byte(十六进制)
编码解码规则
s = 'hello 你好' # str >>>>> bytes: 编码 b = bytes(s,'utf8') print(b) #b'hello \xe4\xbd\xa0\xe5\xa5\xbd' #用utf8编码后的bytes类型 b1 = s.encode('utf8') print(b1) #b'hello \xe4\xbd\xa0\xe5\xa5\xbd' #用utf8编码后的bytes类型 b2 = s.encode('gbk') print(b2) #b'hello \xc4\xe3\xba\xc3' #用gbk编码后的bytes类型 # bytes >>>>>> str: 解码 s = str(b, 'utf8') print(s) s1 = b1.decode('utf8') print(s1) s2 = b2.decode('gbk') print(s2)
.pyc文件
python自动生成的字节码 (提高运行速度)
python优先搜字节码 即原本的.py文件删除也可以
Python的运行过程
在说这个问题之前，我们先来说两个概念，PyCodeObject(.py文件)和pyc文件。
我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果(.py文件)。
当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。
当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。
所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。
变量
Variables are used to store information to be referenced and manipulated in a computer program. They also provide a way of labeling data with a descriptive name, so our programs can be understood more clearly by the reader and ourselves. It is helpful to think of variables as containers that hold information. Their sole purpose is to label and store data in memory. This data can then be used throughout your program.
常量: 不变的量
清空变量(释放内存)
1.del xx
2.重新赋值
注释
单行 #....
多行 '''.....’''
3个引号也可以打印多行
‘ ,” 是一样的 在print 的句子中有1引号则外面用2引号, 相反一样, 若两个都有就用3引号
print() #等价于 print(end=“\n")
print("xxx", end=“”) #end表示语句输出之后跟的东西
print("xxx", end=“_")
用户输入
name = input(“what is your name”) 数据为字符串
raw_input(“xxx”) for python 2.x
import getpass
pwd = getpass.getpass(“enter password”)
print(pwd)
类型转换
int()
str()
数据类型:
不可变类型: 整型, 字符串, 元祖
可变类型: 列表, 字典
1.数字
整数 int(integer)
整型
长整型
py3 已经不区分整型与长整型，统一都叫整型
bit_length 当前数字的二进制, 至少用n位表示 (位数)
r = age.bit_length()
2.布尔 只有2种状态，分别是
真 True
假 False
通常用变量名flag 意为标志位
3.字符串
salary.isdigit()
计算机中， 一切皆为对象
oop:世界万物，皆为对象，一切对象皆可分类(模子)
# 1 * 重复输出字符串
print('hello' * 2)
# 2 [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表
print('helloworld'[2:])
# 3 in 成员运算符 - 如果字符串中包含给定的字符返回 True
print('el' in 'hello')
# 4 % 格式字符串
格式化输出
占位符
%s s = string
%d d = digit
%f f = float
print('alex is a good teacher')
print('%s is a good teacher' % 'alex')
# 5 + 字符串拼接
print(“hi”,”hi”, “hi”)
or print(“hi”+”hi”+“hi”) 但是计算机开辟了5块内存去储存 效率低
用join
d2 = ''.join([a, b, c])
4.列表
创建
a = [1,2,3]
a = list((1,2,3))
查
索引(下标) ，都是从0开始
切片
.count 查某个元素的出现次数
.index 根据内容找其对应的位置
“x" in a
增加
a.append() 追加
a.insert(index, "内容")
a.extend 扩展
修改
a[index] = "新的值"
a[start:end] = [a,b,c]
删除
remove("内容")
pop(index) index为空 默认删除最后一个元素
del a, del a[index]
a.clear() 清空
排序
sort ()
reverse()
sort(reverse = True)
b = sorted(a)
身份判断
>>> type(a) is list
True
>>>
其他
cmp(a,b)
len(a)
max(a)
深浅拷贝
浅拷贝: 只拷贝内存地址第一层
a = [[1,2],3,4]
b = copy.copy(a)
若修改b, a不会变 但是在浅拷贝中若修改b[0][0], 则a也会改变, 因为这是内存地址第二层, 两者仍然共享
a = b 两者共享同一个内存地址, 所以不论哪个修改 另一个都会变
深拷贝: deepcopy()
b = copy.deepcopy(a)
5.元组tuple
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组。
元组写在小括号(())里，元素之间用逗号隔开。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表.
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
作用： 1. 对于一些数据我们不想被修改，可以使用元组； 2. 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在
6.字典 特点:无序, 键唯一
字典是python中唯一的映射(一一对应的关系)类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
创建字典：
dic1={'name':'alex','age':36,'sex':'male’} 由键值对组成, name为键 alex为值, 键是唯一且不可变类型的(不可修改)
dic2=dict((('name','alex'),))
print(dic1)
print(dic2)
读:
dic = {'name': 'charon'}
print(dic['name']) #charon
print(dic.get('name')) #charon
print(dic.get('fkjrnf')) #None
print(dic.get('fkjrnf','few')) #若前面一个参数找不到, 则默认返回后面一个参数few
增:
dic['age'] = 18 #字典是无序的且通过键值取值, 所以无所谓添加顺序
setdefault 若键存在, 不改动, 返回字典中相应的键的值
setdefault 若键不存在, 在字典增加新的键值, 并返回相应的值
dic.setdefault('hobby', 'girl') #有返回值
查:
print(dic['name'])
print(dic.keys()) #打印所有的键 其返回的类型是一种dict_keys()的类型 可以将其转换为list
print(list(dic.keys()))
print(dic.values()) #打印所有的值 也可用list()转
print(dic.items())
改:
dic['age'] = 22
dic3={'1':'111', '2':'222'}
dic.update(dic3) #若有相同的键值, 则覆盖
删:
dic.clear()
del dic['1']
rec = dic.pop('2') #删除及返回值
dic.popitem() #随机删除
其他:
dic4=dict.fromkeys(['host1', 'host2', 'host3'], 'test') #创建 类似初始化的效果 少用
嵌套:
排序 根据键排序
print(sorted(dic))
遍历:
for i in dic: #效率高
print(i, dic[i])
for i,j in dic.items():
print(i, j)
7.集合(set)
集合是一个无序的，不重复的数据组合，把不同的元素组成一起形成集合, 它的主要作用如下：
- 去重，把一个列表变成集合，就自动去重了
- 关系测试，测试两组数据之前的交集、差集、并集等关系
创建:通过关键字创建
s = set(‘charon')
集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键
访问:
print(‘c’ in s)
for i in s:
print(s)
更新集合:
s.add() #添加一个元素
s.update() # 添加多个元素 s.update([12, 'alan'])
s.remove()
s.pop()
s.clear()
集合类型操作符:
1.in, not in
2.集合等价于不等价(==, !=)
3.子集,超集 set(‘alan’) < set(‘alanooo') 判断前一个集合是否为后一个集合的结果 答案为True > a.issuperset(b) a是否完全包含b < a.issubset(b) b是否完全包含a
4.联合(|) s1|s2 s1.union(s2) 所有元素
5.交集(&) s1&s2 s1.intersection(s2) 两者共有元素
6.差集(-) s1-s2 s1.difference(s2) 后者中没有的前者的元素
7.对称差集(^) s1^s2 s1.symmetric_difference(s2) 元素属于两者但不同时属于前者和后者
Python必须缩进
//输出取整
**次方
x is not y like x != y x is y like x == y is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等
>>> a = 123456
>>> b = a
>>> b is a #判断 a 和 b 是不是同一个 123456
True
>>> c = 123456
>>> c is a #判断 c 和 a 是不是同一个 123456
False
>>> c is not a #判断 c 和 a 是不是不是同一个 123456
True
第一次 将123456赋值给a的时候，在内存里开辟了一块空间，将123456放在这块空间里，为了找到这里的123456， 会有一个指向这块空间的地址，这个地址叫做内存地址，是123456存储在内存中的地址。a其实指向的就是存储123456的内存空间的地址。执行了b=a，就是让b指向的地址和a一样。之后我们执行了 c = 123456 ，这里就会再开辟一块内存空间，并将指向该空间的内存地址赋值给c ，这样的话 ，a和b 指向的是同一个123456, c 指向的是另外一个123456 。
优先级: ( ) > not > and > or
短路原则
python里面没有x++ x-- 只能x+=1
表达式:
是由操作数和运算符组成的一句代码或语句, 表达式可以求值, 可以放在=的右边, 用来给变量赋值
if表达式
if xx>90: print(“A”) elif xx > 80: print(“B”) else: print(“C”)
while表达式
while condition :
statement….
else:
break
continue
python里的while可以和else一起用 但是这里的else语句，只有在循环正常结束的时候才会执行 若执行了break语句，这里的else语句就不会被执行
#4x4方块 num = 4 while num >0: num1 = 4 while num1 >0: print("#", end="") num1 -= 1 print() num -= 1 #九九乘法表 first = 1 while first <= 9: sec = 1 while sec <= first: print(str(first)+"*"+str(sec)+"=", first*sec, end="\t") sec+= 1 print() first+=1
for表达式 (i不能改变)
for i in range(3):
print(i)
else:
python里的for可以和else一起用 但是这里的else语句，只有在循环正常结束的时候才会执行 若执行了break语句，这里的else语句就不会被执行
range(3) = [0,1,2]
range(1,4) = [1,2,3]
range(1,6,2) = [1,3,5] 2为步长的意思
!!!!能调用方法的一定是对象
文件操作:
对文件操作流程
- 打开文件，得到文件句柄并赋值给一个变量 f = open(‘test’)
- 通过句柄对文件进行操作 data = f.read()
- 关闭文件 f.close()
- r代表read mode
- w为write mode若有文件则清空,若无则创建新未见
- a为append mode 添加
- f = open('test','r’)
f = open('test','r')
data = f.read() #read里面的参数为一个字符 print(f.tell()) #打印光标位置 print(f.read(10)) print(f.tell()) #在tell中若是英文占一个字符,若是中文占三个 f.seek(0) #调整光标位置
读取文件方法 # a = f.readline() # print(a) # b = f.readlines() # print(b) # cnt = 0 # for i in f.readlines(): # #print(i.strip()) # cnt+=1 # if cnt == 6: # i = ''.join([i.strip(),'***']) # print(i.strip()) # for index,line in enumerate(f.readlines()): #用enumerate 所以有index # if index==2: # line=''.join([line.strip(),'end 3']) # print(line.strip()) #最优Best Method!!!!!最不消耗内存 for i in f: #这是for内部将f对象做成一个迭代器, 用一行去一行 print(i.strip())
- #f = open('test','w')
- #f = open('test','a’)
# 在terminal上操作:
f = open('test1', 'w') f.write('hello \n') f.flush() #清空缓冲区 将缓冲区的内容冲到内存输出 f.write('world') # 应用:进度条 import time,sys for i in range(30): sys.stdout.write("*") sys.stdout.flush() time.sleep(0.1) print('') for i in range(30): print('*',end='',flush=True) time.sleep(0.1) # f = open('test2','w') # f.truncate()#光标之后的全部截断(清空) # f.truncate(5)#全部截断 # print(f.isatty()) # print(f.seekable()) # print(f.readable())
r+, w+, a+
f = open('test','r+') print(f.readline()) f.write('岳飞') #只能从文件最后添加 # f = open('test','w+') # print(f.readline()) # f.write('岳飞') #write内容覆盖文件 光标跑到内容之后 所以readline为空 需要将光标调到内容前面 # f.seek(0) # print(f.readline()) # f = open('test','a+') # print(f.tell()) #添加模式 光标默认在最后 # print(f.readline()) # f.seek(0) # print(f.readline()) #对文件内容进行修改!!! #若要在文件第三行后面添加内容 # f = open('test','r+') #以写读模式打开文件 # f.readline() # f.readline() # f.readline() # print(f.tell()) # f.write('hello 岳飞') #只能在文件最后添加内容 所以无用 # f.close() #以上内容无用 f_read = open('test','r') #以写读模式打开文件 f_write = open('test_back','w') #以写读模式打开文件 # count=0 # for line in f_read: # count += 1 # if count==3: # f_write.write('hello,岳飞\n') # # else: # f_write.write(line) count=0 for line in f_read: count += 1 if count==3: line = ''.join([line.strip(),'hello,岳飞\n']) #line = 'hello,岳飞\n' f_write.write(line) f_read.close() f_write.close()
with语句
#为了避免打开文件后忘记关闭，可以通过管理上下文，即： with open('log','r') as f: .... #with又支持同时对多个文件的上下文进行管理，即： with open('log1','r') as f_read, open('log2','w') as f_write: ...
浙公网安备 33010602011771号