Python(二)字符串操作、列表字典及深浅拷贝等

目录

模块初识
.pyc是什么？
数据类型初识
字符串操作
列表、元组操作
字典操作
深copy和浅copy

一、模块初识

Python的强大之处在于他有非常丰富和强大的标准库和第三方库。
一般标准库 在 Lib 目录
第三方库：在 site-packages

sys模块（python解释器的sys模块，用c语音写的，Lib目录下没有sys.py）

sys.path  # python调用模块时，查找的python全局环境变量sys.argv  # 参数，类似shell脚本中的的$1、$2、$3

#!/usr/bin/env python#coding=utf-8import sysprint(sys.argv)#输出$ python test.py helo world['test.py', 'helo', 'world']  # 把执行脚本时传递的参数获取到了

os模块

os.system('dir')  # 调用系统命令，不保存结果# 结果直接输出在屏幕上，返回结果只是命令执行状态# 保存结果使用os.popen()cmd = os.popen('dir'): print(cmd)  # 打印的是内存地址cmd_res = os.popen('dir').read()print(cmd_res)  # 打印命令结果os.mkdir('new_dir')  # 创建目录

结合一下　

import os,sysos.system(''.join(sys.argv[1:]))  # 把用户的输入的参数当作一条命令交给os.system来执行

import 导入模块
先查找当前目录，当前目录没有，再去环境变量中找

二、.pyc是什么？

python是解释型语言，那么生成的*.pyc文件是什么呢？c应该是compiled的缩写才对啊！
一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上接近编译型语言。
此外，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种。
用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

其实Python和Java/C#一样，也是一门基于虚拟机的语言
简述Python的运行过程
当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。
当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。
判断更新时间，执行py还是pyc。

3.x : .pyc在__pycache__目录，无py文件，导入会报错2.x ：.pyc在当前目录，无py文件，pyc可以导入使用

说pyc文件其实是PyCodeObject的一种持久化保存方式。

三、数据类型初识

1、数字

• int（整型）
  　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
  　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
  　　这也是为什么32位系统内存最大为4G的原因。4G=4*1024M*1024k*1024-1 = 2147483647-(-2147483648)
• long（长整型）
  从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数
  python3 已经不区分int和long

# Python 2.x版本type(2**32) >> inttype(2**64) >> long

• float（浮点型）
  浮点数用来处理实数，即带有小数的数字。
  浮点数是属于有理数中某特定子集的数的数字表示，小数包括有理数和无理数。
  所以浮点数一定是小数，小数不一定是浮点数。
  浮点计算是指浮点数参与的运算，这种运算通常伴随着因为无法精确表示而进行的近似或舍入。
• 复数
  由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

底层加减乘除是用的位运算。位移 “<<” “>>” ，比除法快

移1位除2，移2位除2**2 取整>>> 64 >> 38

三元运算：

a,b,c = 1,3,5d = a if a > b else c

2、布尔值

    True  False    1       0

3、字符串
Python 3最重要的新特性大概是对文本和二进制数据做了更为清晰地区分。文本总是Unicode，由str类型表示，二进制数据由bytes类型表示。Python 3不会以任意隐式的方式混用str和butes，正因为此，python 3不能拼接字符串和字符包，也无法在字节包里搜索字符串，不能讲字符串传入参数为字节包的函数。
str 转为 bytes – encode

>>> "fgf".encode('utf-8')b'fgf'>>> "活着".encode('utf-8')      # utf-8编码转为二进制b'\xe6\xb4\xbb\xe7\x9d\x80'# python 2.x 不指定编码，则使用系统编码# python 3.x 不指定编码，则使用utf-8

bytes 转为 str – decode

>>> b'\xe6\xb4\xbb\xe7\x9d\x80'.decode('utf-8')'活着'                          # 二进制转为utf-8编码

python 数据传输，都是以二进制数据传。

二进制和十六进制的转化

十六进制：二进制每4位表示16进制的一位。对应关系如图

0 1 2 3 4 5 6 7 8 9 A B C D E F 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

二进制转换成十六进制的方法是，取四合一法，即从二进制的小数点为分界点，向左（或向右）每四位取成一位

1011 1001 1011 1001  # 二进制 v    v    v    v         V B    9    B    9    # 十六进制

注意16进制的表示法，用字母H后缀表示，比如BH就表示16进制数11；也可以用0X前缀表示
在向左（或向右）取四位时，取到最高位（最低位）如果无法凑足四位，就可以在小数点的最左边（或最右边）补0，进行换算

将十六进制转为二进制，一分四，即一个十六进制数分成四个二进制数，用四位二进制按权相加，最后得到二进制，小数点依旧就可以

 B    F    4 .  B    5    # 十六进制 v    v    v    v    v        V1011 1111 0100.1011 0101  # 二进制

判断一个变量的类型

>>> num = 27>>> isinstance(num, str)    # 判断变量类型False>>> type(num)               # 获取变量类型<class 'int'>

四、字符串操作

• 大小写处理

name = "fgf"name.capitalize()           # 首字母大写name.lower()                # 全小写name.upper()                # 全大写name.swapcase()             # 大小写转换

• 字符串格式判断

name.isdigit()              # 是不是整数name.isidentifier()         # 判断是不是合法的标识符name.isalnum()              # 是不是字母和数字，阿拉伯name.isalpha()              # 是不是字母name.istitle()              # 是否首字母大写name.issupper()             # 全大写name.endswith("f")          # 是否以什么结尾name.startswith("-")        # 是否以负号开头

• 格式化输出

name.format()               # 字符串格式化输出name.center(50,"-")         # 打印50个字符，不够-补足name.ljust(50,"*")          # 字符在左，空位*填充name.rjust(50,"*")          # 字符在右，空位*填充"f\tgf".expandtabs(30)      # 把tab转成多少个空格name="1"name.zfill(2)               # 补位

• 字符空格回车处理

name = "\n\n  fgf \n"name.strip()                # 去除空格回车tabname.lstrip()               # 去除左边空格回车tabname.rstrip()               # 去除右边空格回车tab

• 字符串处理

name.split()                # 切片"+".join(["1","2","3"])     # 字符串拼接name.count('f')             # 统计个数name.find("gf")             # 找它的索引"fgf".replace('f','F',1)    # 字符替换，几次

• 其他

                            # 类似加密转化>>> p = str.maketrans("cdef","1234")>>> print('fgf'.translate(p))4g4>>>msg = '''fgf'''>>>name.splitlines(msg)     # 以每行切片

五、列表、元组操作

列表

命名规则“[]”    name = ["A","B","C","D","E"]取值    print(name[0], name[1])     print(name[1:3])            # 切片，顾头不顾尾    name[-1]                    # 取最后一个    # name[-1:-3]               # 从左往右，这样取不到值    name[-3:-1]                 # 取倒数第三到最后一个    name[-2:]                   # 取最后两个添加：    names.append("")            # 追加    names.insert(1,"")          # 插入哪写哪修改：    names[2] = ""               # 修改删除：    names.remove("fgf")         # 删第一个从左往右    del names[1]    names.pop(1)                # 坐标为空则删最后一个取下标：    names.index("fgf")          # 取下标统计：    names.count("fgf")          # 统计排序： # 按ascii码排序，符号、数字、大写小写    names.sort()                # 排序反转：    names.reverse()             # 反转清除列表：    names.clear()               # 清空扩充：    names2 = [1,2,3,4]    names.extend(name2)         # 扩充    del names2  # 删掉变量遍历：    for i in names:             #遍历列表        print i步长    range(1,10,2)       names[0:-1:2]  <-->  names(::2)

元组
元组（）：又称：只读列表
只有 count index 两个方法

六、字典操作

字典一种key - value 的数据类型
语法:

info = {    'stu1101': "台湾",    'stu1102': "钓鱼岛",    'stu1103': "南海",}

字典的特性：

• dict是无序的
• key必须是唯一的,so 天生去重

增加或修改    info["stu"] = "fgf"         # 存在为修改，不存在为添加删除    del info["stu"]             # 删除    info.pop("stu")查找    "fgf" in info               # 标准用法    info.get("stu")             # 获取    info["stu"]                 # 如果不存在，就报错，get不会，不存在返回None-----------------------------------------------------------------------------取Values    info.values()取keys    info.keys()setdefault    info.setdefault("stu1102", "小日本")  # key有则不变，没有就创建update    b = {1:2,3:4, "stu1102":"钓鱼岛是中国的"}    info.update(b)              # 类似列表的extendinfo.items()

循环字典

# 方法1for index,item in enumerate(info):    print(index,item)# 方法2for key in info:  # 效果一样，比下面高效    print(key,info[key])# 方法3for k,v in info.items(): #会先把dict转成list,数据里大时莫用    print(k,v)

七、深copy和浅copy

1. 数字和字符串
   上篇提了：对于数字数字和字符串一旦创建便不能被修改，假如对于字符串进行替代操作，只会在内存中重新生产一个字符串，而对于原字符串，并没有改变。

2. 字典、列表等数据结构

alphabet = ["A","B","C",["L","M","N"]]alphabet2 = alphabet.copy()alphabet3 = alphabetimport copyalphabet4 = copy.copy(alphabet)alphabet5 = copy.deepcopy(alphabet)

请想一下：如果对alphabet的值做更改，其他四个变量的值会不会变化呢？

alphabet[2] = 2alphabet[3][1] = 7>>> alphabet['A', 'B', 2, ['L', 7, 'N']]

下面分别看一下其他四个变量的值：

>>> alphabet    # 更改后的值['A', 'B', 2, ['L', 7, 'N']]>>> alphabet2   # list.copy()['A', 'B', 'C', ['L', 7, 'N']]>>> alphabet3   # "="赋值['A', 'B', 2, ['L', 7, 'N']]>>> alphabet4   # copy.copy()['A', 'B', 'C'['L', 7, 'N']]>>> alphabet5   # copy.deepcopy()['A', 'B', 'C'['L', 'M', 'N']]

总结一下
1、直接“=”赋值，都指向同一个内存地址，alphabet变，alphabet3也变。和简单的数字、字符串不一样
2、list.copy()和copy模块的copy.copy()一样，都是浅copy，只copy了第一层，下面的层只是copy内存地址，源变量深层被更改，则更改。
3、完全克隆，不只拷贝内存地址，则要深copy，使用copy模块的copy.deepcopy()

转载请务必保留此出处：http://blog.csdn.net/fgf00/article/details/52098926

字典的fromkeys用法也是一样。如下：

>>> deposit = dict.fromkeys(['husband','wife'],{"总存款：":"100w"})>>> deposit{'husband': '100w存款', 'wife': '100w存款'}>>> deposit['husband']["总存款："] = "80w">>> deposit{'husband': {'总存款：': '80w'}, 'wife': {'总存款：': '80w'}}# 改其中一个的值，其他的值就都改了。第一层不变，深层就都变了，