Python的平凡之路（2）

一、标准库(sys & os)：

 

Python 的标准库(standard library) 是随着 Python 一起安装在你的电脑中的，是 Python 的一部分 (当然也有特殊情况。有些场合会因为系统安全性的要求，不使用全部的标准库，比如说Google App Engine)。利用已有的类(class)和函数(function)进行开发，可以省去你从头写所有程序的苦恼。

“这些标准库就是盖房子已经烧好的砖，要比你自己去烧砖来得便捷得多 ” ---解释的太到位!

sys.path 打印环境变量

sys.argv  打印当前脚本路径（相对）

 

例子：

sys_mod.py

#!/usr/bin/env python

import sys

print(sys.argv[0]) 

print(sys.argv[2])

 

python sys_mod.py 0 1 2 3  #1 2 3 代表传参,返回结果为sys_mod.py  1

 

os_mod.py

#!/usr/bin/env python

import os

cmd_res = os.popen('pwd').read()

#print(cmd_res)

print("-->",cmd_res)

 

python  os_mod.py

 

标准库地址  lib/python3.5

第三方库地址 lib/python3.5/site-packages

 

*引入自定义模块（self.py)，一定要和当前脚本在同一级目录！（也可以放在site-packages目录下） 在当前脚本中导入自定义模块，使用命令import  self

 

Pycodeobject、pyc是什么鬼？ python程序将编译的结果放到内存中的pycodeobject中，pyc文件其实是pycodeobject的一种持久化方法

 

 

二、数据类型：

 

int（整数）分 普通整数和长整数，普通整数长度为机器位长，通常都是32位，超过这个范围的整数就自动当长整数处理，而长整数的范围几乎完全没限制
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。取值范围 分32位和64位 

 

long（长整型）#3.5已经没了。

 

float（浮点型）数学中的小数，类似C语言中的double。在运算中，整数与浮点数运算的结果是浮点数

 

complex（复数） 略

 

布尔值     1 真 0 假

 

*字符串   Python字符串即可以用单引号也可以用双引号括起来，甚至还可以用三引号括起来
 字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来

 

bytes 二进制 #python3中的特性，譬如视频文件 音频文件

 

例子：

b.py

#!/usr/bin/env python

msg = "我爱北京天安门"
print(msg.encode(encoding="utf-8"))
print(msg.encode(encoding="utf-8").decode(encoding="utf-8"))

 

 

三、Python运算：

 

算数运算：

操作符	描述符	例子
+	加法 - 对操作符的两侧增加值	a + b = 30
-	减法 - 减去从左侧操作数右侧操作数	a - b = -10
*	乘法 - 相乘的运算符两侧的值	a * b = 200
/	除 - 由右侧操作数除以左侧操作数	b / a = 2
%	模 - 由右侧操作数和余返回除以左侧操作数	b % a = 0
**	指数- 执行对操作指数（幂）的计算	a**b = 10 的幂 20
//	地板除 - 操作数的除法，其中结果是将小数点后的位数被除去的商。	9//2 =  4 而 9.0//2.0 = 4.0

 

比较运算：

 

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是，则条件变为真。	(a == b) 为 true.
!=	检查两个操作数的值是否等相等，如果值不相等，则条件变为真。	(a != b) 为 true.
<>	检查两个操作数的值是否等相等，如果值不相等，则条件变为真。	(a <> b) 结果为true。这类似于!=运算符。
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	(a > b) 为  true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	(a < b) 为true.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	(a >= b) 不为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	(a <= b) 为 true.

 

 

赋值运算：

运算符	描述	示例
=	简单的赋值运算符，赋值从右侧操作数左侧操作数	c = a + b将指定的值 a + b 到  c
+=	加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数	c += a 相当于 c = c + a
-=	减AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数	c -= a 相当于 c = c - a
*=	乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数	c *= a 相当于 c = c * a
/=	除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数	c /= a 相当于= c / a
%=	模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数	c %= a is equivalent to c = c % a
**=	指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数	c **= a 相当于 c = c ** a
//=	地板除，并分配一个值，执行地板除对操作和赋值给左操作数	c //= a 相当于 c = c // a

 

 

逻辑运算：

运算符	描述	示例
and	所谓逻辑与运算符。如果两个操作数都是真的，那么则条件成立。	(a and b) 为 true.
or	所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。	(a or b) 为 true.
not	所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真，则逻辑非运算符将返回false。	not(a and b) 为 false.

 

 

成员运算：

操作符	描述	示例
in	计算结果为true，如果它在指定找到变量的顺序，否则false。	x在y中，在这里产生一个1，如果x是序列y的成员。
not in	计算结果为true，如果它不找到在指定的变量顺序，否则为false。	x不在y中，这里产生结果不为1，如果x不是序列y的成员。

 

 

标识运算：

运算符	描述	例子
is	计算结果为true，如果操作符两侧的变量指向相同的对象，否则为false。	x是y，这里结果是1，如果id（x）的值为id（y）。
is not	计算结果为false，如果两侧的变量操作符指向相同的对象，否则为true。	x不为y，这里结果不是1，当id（x）不等于id（y）。

 

 

 

位运算：

运算符	描述	示例
&	二进制AND操作复制一位到一个结果数，如果存在两个操作数。	(a & b) = 12 即  0000 1100
|	二进制或复制操作了一个比特，如果它存在一个操作数中。	(a | b) = 61  即 0011 1101
^	二进制异或运算符的副本，如果它被设置在一个操作数而不是两个比特。	(a ^ b) = 49  即 0011 0001
~	二进制的补运算符是一元的，并有“翻转”位的效果。	(~a ) =  -61  即 1100 0011 以2的补码形式由于带符号二进制数。
<<	二进位向左移位运算符。左操作数的值左移由右操作数指定的位数。	a << 2 = 240 即 1111 0000
>>	二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动。	a >> 2 = 15 即  0000 1111

 

 

运算符优先级：

运算符	描述
**	幂（提高到指数）
~ + -	补码，一元加号和减号（方法名的最后两个+@和 - @）
* / % //	乘，除，取模和地板除
+ -	加法和减法
>> <<	左，右按位转移
&	位'AND'
^ |	按位异'或`'和定期`或'
<= < > >=	比较运算符
<> == !=	等式运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	标识运算符
in not in	成员运算符
not or and	逻辑运算符

 

 

三元运算

python3中不等于使用!=

-= 减法赋值运算符

+-加法赋值运算符

 

 

四、列表、元组：

 

列表是（list）是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的（mutable）——可以改变列表的内容。列表可以使用所有适用于序列的标准操作，例如索引、分片、连接和乘法。

 

元组是不可变序列, 是只读列表，用小括号书写，只有count、index用法可用 ? //可练习

例子：

list.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-

#!/usr/bin/env python

names = ["zhangyang","guying","wangchen"]

print(names[0],names[2])
print(names[1:2]) #切片
print(names[2])   #切片
print(names[-1])  #切片
print(names[-2:]) #切片,取最后两个数，从左往右数
print(names[:3])  #切片，前边的0可以省略掉
names.append("leihaidong") #追加
names.insert(1,"chenronghua")  #插入
names.insert(3,"xinzhiyu")  #插入
print(names)
names[2]="xidi" #替换
print(names)
names.remove("chenronghua") #删除
print(names)
#del names[1] #删除
#names.pop[1] #删除
print(names.index('xidi')) #找出某人的位置
print(names[names.index('xidi')]) #通过位置，找到某人

print(names.count("chengronhua")) #统计出现了多少次

names.reverse() #翻转
print(names)

names.sort() #排序
print(names)

names2 = [1,2,3,4]
names.extend(names2) #扩展
#del names2
print(names)

print(names,names2)

 

import copy
n = ['a','b',['c','d'],'e']
#深COPY,第二份发生变化,第一份不发生变化
n2 = copy.deepcopy(n)
print(n)
print(n2)

n2[2][0] = 'wkk'
print(n)
print(n2)

#浅COPY,如果第二份发生变化,第一份发生变化

n3 = copy.copy(n）

n3[2][0] = 'sss'
print(n)
print(n3)

 

#列表循环

for i in names:

    print(i)

#步长切片

print(names[0:-1:2]) 

print(names[::2])  

 

 

五、字符串：

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。创建字符串很简单，只要为变量分配一个值即可。

例子：

str.py

#!/usr/bin/env python

name = “alex"

print(name.capitalize())

print(name.count(“a”))

print(name.center(50,“k“))

print(name.find(“name”))

name = “name is {name} and i am {year} old” 

*print(name.format(name=‘alex’,year=23))

print(‘ab’.isalpha())  #判读是否纯英文 

print(‘a1’.isdigit())    #判读是否纯数字

print(‘My Name Is’.isupper()) #判读是大小写

print(‘,’.join([‘1’,’2’,’3’]))

print(name.just(50,’*’))

print(name.rust(50,’---’))

print(‘ALEX’.lower())

print(‘alex’.upper())

print(‘\nAlex’.lstrip())  #去左边的空格和回车 去右边的空格和回车使用rstrip

 

#随机密码加密

p = str.maketrans(‘abcdef’,’123$56’) 

print(“alex li”.translate(p))

 

print(‘alex li’.replace(‘l’,’L’,1)) #   l被L替换，只替换1次

print(‘1+2+3+4’.split(‘+’))   #分隔

*

print("alex li".title())#手写字母大写

 

 

六、字典： 

 

字典是Python语言中唯一的映射类型。映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。

字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

key-value数据类型

例子：

info = {
   'stu1101': "TengLan Wu",
   'stu1102': "LongoingZe Luola",
   'stu1103': "XiaoZe  MaliYa"
       }
print(info)

print(info["stu1101"])
info["stu1101"] = "武藤兰"
info["stu1104"]  = "cangjingkong"
print(info)

del info["stu1101"]  # info.pop(“stu1101”)
print(info)

print(info.get('stu1108'))  #获取键值
print('stu1108' in info)    # 判断键值是否存在。。。。
info.values()
info.keys()
info.setdefault("taiwan",{"www.baidu.com:[1,2]"})

#字典是无序的
#key必须是唯一的，天生去重

b = { 'stu1101': "Alex",1:3,2:5}
info.update(b)
print(info)

c = info.fromkeys([6,7,8],"test")
print(c)

for i in info:
     print(i,info[i])  #字典循环，取出Key Value，效率高

for k,v in info.items():
    print(k,v)     #字典循环，取出Key Value ，效率低

 

七  集合：

 

定义：无序的、不重合的数据组合

作用：去重、关系测试

举例：

set.py

#!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-

list_1 =  [1,4,5,7,3,6,7,9]

list_1 = set(list_1)
list_2 = set([2,6,0,66,22,8,4])
print(list_1,type(list_1))
print(list_1,list_2)

#交集
#print(list_1.intersection(list_2))
print(list_1 & list_2)

#并集
#print(list_1.union(list_2))
print(list_1 | list_2 )
#差集
#print(list_1.difference(list_2))
#print(list_2.difference(list_1))
print(list_1 - list_2 )

#子集
list_3 = set([1,3,7])
print(list_1.issubset(list_2))
print(list_3.issubset(list_1))

#父集
print(list_1.issuperset(list_2))

#对称差集(把两个集合中相同的去掉)
print(list_1.symmetric_difference(list_2))

print("--------------")
#判断是否是交集,如果没有则为True
list_4 = ([5,6,8])
list_5 = ([8,3,9])
print(list_3.isdisjoint(list_4))

print(list_3.isdisjoint(list_5))

 

#添加集合
list_1.add(999)
list_1.update([666,777,888])
print(list_1)
list_1.remove(9)

#项不存在,删除报错
#list_1.remove(222)

#随意删除
list_1.pop()

#指定删除项,区别于remove如果项不存在也不报错,
list_1.discard(777)
print(list_1)

#包含不包含
print(999 in list_1)
print(555 in list_1)

八  文件：

 

1 打开文件，得到文件句柄并赋值给一个变量

2 通过句柄对文件进行操作

3 关闭文件

file.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-

#data = open("yesterday",encoding="utf-8").read()
'''
f = open("yesterday",'r',encoding="utf-8",) #f就是文件句柄
data = f.read()
data2 = f.read()
print(data)
print("----Continue----",data2)

f = open("yesterday2",'w',encoding="utf-8",) #w写
f.write("我爱北京天安门,\n")
f.write("天安门上太阳升")

f = open("yesterday2",'a',encoding="utf-8",) #a追加
f.write("\n亲爱领袖毛委员\n")
f.write("带领我们向前进")

f.close()
'''
f = open("yesterday2",'r',encoding="utf-8",)

#for i in range(5):
#   print(f.readline())
#f.close()'''

#print(f.readlines())
#f.close()

#for line in f.readlines():
#    print(line.strip())
#f.close()

#for index,line in enumerate(f.readlines()):
#    if index == 2:
#        print('-------FG-------')
#        continue
#    print(line.strip())
#f.close()

#高逼格的循环,要理解!
count = 0
for line in f:
    if  count == 2:
        print('---FG---')
        count += 1
        continue
    print(line)
    count += 1
f.close()

f2 = open("yesterday2",'r',encoding="utf-8",)
print(f2.tell()) #查询含义?
f2.seek(10) #指定到特定位置
#f2.truncate(40) #截断
print(f2.tell())
print(f2.flush()) #缓存写入

#理解读写模式 r+ 写读模式 w+  rb 二进制读  wb 二进制写

mfile.py

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
f = open("yesterday","r",encoding="utf-8")
f_new = open("yesterday_bak",'w',encoding="utf-8")

#高逼格循环逐行读取文件
for line in f:
    #字符串匹配
    if "肆意的快乐等我享受" in line:
        line = line.replace("肆意的快乐等我享受","肆意的快乐等wspkh享受")
    #else: #可以省略掉
    f_new.write(line)

f.close()
f_new.close()

#头脑风暴,变量替换!
'''
find_str = sys.argv[1]
replace_str = sys.argv[2]
for line in f:
    #字符串匹配
    if find_str in line:
        line = line.replace(find_str,replace_str)
    #else: #可以省略掉
    f_new.write(line)

f.close()
f_new.close()
'''
#with语句可避免打开文件后忘记关闭
with open("yesterday2","r",encoding='utf-8') as k:
      for line in k:

          print(line)

 

九  字符编码与转码：

 

utf-8可变长字符编码，中文字符统一是3个字节。

 

 

encode_py2.py

#!/usr/bin/env python

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

#打印系统默认编码

#PY2里边默认的是ASCII码

import sys

print(sys.getdefaultencoding())

 

s = “您好“

s_to_unicode = s.decode(“utf-8”)  #utf-8转Unicode

print(s_to_unicode)

print(s_to_unicode,type(s_to_unicode))

s_to_gbk = s_to_unicode.encode(“gbk”) #Unicode转GBK

print(s_to_gbk)

 

encode_py3.py

#Author is wspikh
# -*- coding:gbk -*-
#适用于PY3

#打印系统默认编码
import sys
print(sys.getdefaultencoding())

s = "您好"
s_to_gbk = s.encode("gbk")
print(s_to_gbk,type(s_to_gbk))

 

#gbk转utf-8(不用编码为Unicode,默认Unicode)

gbk_to_utf8 = s_to_gbk.decode("gbk").encode("utf-8")

print("utf-8",gbk_to_utf8)

 

s = U"我的生活"
print(s)

 

#参考文章 http://www.cnblogs.com/luotianshuai/articles/5735051.html