3版本中   .pyc 会 移到    __pycache__ 目录下，名称 为  *.cpython-32.pyc

java是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成及其文件，所以JAVA是一种先编译后解释的语言

python和Java/c# 一样，也是一门基于虚拟机的语言，

而python执行时先自动编译，执行py 脚本时，其实是激活了python的解释器，告诉解释器，你要开始工作了，可在解释之前，其实执行的第一项工作和java一样，是编译 ，python也是 先编译后解释的语言

当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当python程序运行结束时，python解释器则将PyCodeObjec写回到.pyc文件， .pyc 字节码文件，python解释器读懂，  当程序第二次运行时，首先寻找.pyc文件，如果找到，则直接载入。可以说 .pyc文件是 PyCodeObject 的一种持久保存方式

而手动执行的 py脚本不会生成.pyc  ,模块导入时 会生成。 且 会比对 .py  和 ,pyc 文件最新时间，如果 .py 修改了，则重新生成 .pyc

 

1、切片

name[0:2]

name[起始位置:终止位置]      如 name[-5:-1]     -1 是最后一个   name[-5:]      name[-1:-5]则向右出界了

name.insert(2,‘123‘)          //插入到 2 这个位置，值为 123

name.append(‘123‘)

name.remove(‘123‘)     //删除值

 

del  删除内存中的数据，可以用来删除 列表中多个元素   del name[4:6]

         del name    删除整个列表

 

print(name[0:-1:2])      2为步长，隔一个输出一个 这里有  -1 标示 最后一个如果正好隔位输出时，是不会打印的

 print(name[::2])     整个列表，2为步长，隔一个输出一个

 

print(99 in name)       // 列表中是否存在 99   返回 True 或 False

 

name.count(‘a‘)              //返回列表中 a 的个数

 

name.clear()           // 清空列表

 

name.extend(name2)       //合并列表，将 name2列表追加到name后

 

name.reverse()       //反转列表

 

name.sort()      //排序 (3的版本中，当列表中元素既有数据又有字符时会报错)

 

name.pop(2)      //删除下标为2的元素，如不填则默认删除最后一个

 

name.copy(name2)    // 拷贝 name列表，生成新的 name2 ，注：修改第一层的元素时，互相不影响，如果有嵌套的列表等，修改其中一个会影响到另一个列表，即列表中只是保存的嵌套的列表的内存地址。

 

import copy

name2=copy.copy(name)        // 效果和 name.copy()  一致

 

要完全拷贝列表，应使用  name2=copy.deepcopy(name) 

 

id(name)    // 查看内存地址

 

直接赋值列表    name2=name     //则完全指向同一个地址，name和 name2 任何一个元素修改都会影响对方

 

len(name)      // 列表长度

 

元组  ： 不可变列表

list((123,234,22))      //把元组转换为列表

       注：原理，list类的初始化函数 __init__  中使用 for循环将元素取出来生成列表

 

分类：移除空白、分割、长度、索引、切片

 

string.strip()       //去掉空白

string.strip(‘\n‘)      //单除掉换行

 

string.split(‘,‘)      //按逗号 拆分字符串为列表

‘|‘.join(list)       //合并列表中各元素，以 | 分割

 

string[2:4]     //字符串切片

 

格式化字符串

msg=‘hello , {name},{age}‘

msg2=msg.format(name=‘Min‘,age=32)

或

msg=‘hello,{0},{1}‘

msg.format(‘Min‘,32)

 

name.center(40,‘*‘)                   //整个字符串扩展为 40个字符，并用 * 均匀填充

‘my name is !‘.center(40,‘*‘)

 

string.find(‘a‘)         //返回a字母的下标，多个a只返回第一个，返回 -1 表示没有找到

 

name.isdigit()      //判断是否是数字,且name必须为字符串

         if name.isdigit():      返回 Ture 执行下面语句

             name=int(name)

         else: 

             print(‘invalid data type‘)

 

name.isalnum()       // 如包含特殊字符则返回False

 

name.endswith(‘df‘)     // 判断是否已 df 结尾

name.startswith(‘dfs‘)    // 判断是否以 dfs 开头

 

name.upper()       // 转换为大写输出

name.lower()      //转换为小写输出

 

 

10%2    返回余数

10//2    返回整数

/           除法

 

赋值运算

+=              // c+=a  等效于  c=c+a

-=              // c-=a  等效于 c=c-a

*=              // c*=a   等效于 c=c*a

.......

 

逻辑运算

and       or      not

 

成员运算

in          not in

 

身份运算

is       判断2个标示符是不是引用自一个对象

         x is y   如果 id(x) 等于 id(y)   返回结果 1

is not    判断2个标示符是不是引用自不同对象

 

位运算

&  按位与运算符       |  按位或运算符     ^ 按位异或

~ 按位取反        << 左移动      >> 右移动

 

key:value   形式， key 必须唯一，如有重复的只会选择一个，字典是无序的，因为key没有固定顺序

 

del namedict[‘addr‘]     //删除 addr 建及值

namedict.pop(‘addr‘)

 

namedict.get(‘addr‘)      //取出键值，且如果键不存在，会返回 None 但不会报错

namedict[‘addr‘]       //如键不存在，则会报错，中断运行

 

namedict.update(dict)                 //使用 dict字典完全覆盖 namedict

 

namedict.items()      //将字典转换为列表，且键值对 放入元组中

 

namedict.values()     //打印字典中所有的值

 

namedict.keys()         //打印字典中所有的键

 

namedict.has_key(‘addr‘)     //在2版本中判断键是否存在

‘addr‘ in namedict

 

namedict.setdefault(‘addr‘,‘beijing‘)  //如果键存在则取出它的值，如果键不存在则添加 addr:beijing  键值对

 

namedict.fromkeys([1,2,3],‘ddd‘)    //将列表中的值转换为字典中的键，值都为 ddd

返回结果  {1:‘ddd‘,2:‘ddd‘,3:‘ddd‘}

与namedict字典本身没有关系，只是借用了 字典的方法

 

namedict.popitem()      //随机删除键值对

 

字典循环取值

方法1：效率低，因为有一个字典转列表的过程

for k,v in namedict.items():

    print(k,v)

 

方法2：

for key in namedict:

    print(key,name[key])

 

enumerate 函数

用于遍历序列中的元素以及它们的下标

例

a=[‘a‘,‘b‘,‘c‘]

for index,i in enumerate(a):

    print(index,i)

返回结果：

(0,‘a‘)

(1,‘b‘)

(2,‘c‘)

 

输出加颜色

31 红色   32 绿色   33黄色

\033[31;1m  %s  \033[0m

 

set  无序，不重复的序列

 

se={‘123‘,‘345‘,‘456‘}                    //创建一个集合

se=set()                     //创建一个空集合

 

sl=set(li)                   //将 li列表转换为集合（可将列表中重复的项去除）

 

se.add(123)            //添加元素

 

se.clear()                 //清除所有内容

 

se.copy()             // 浅拷贝

 

se.discard(11)        //将11元素移除，如元素不存在也不报错

se.remove(11)     //将11元素删除，如元素不存在则会报错

 

 ret=se.pop()               //随机删除一个元素，且会将移除的值赋值给 ret  无参数

        

集合操作

s1={11,22,33}

s2={22,33,44}

s3=s1.difference(s2)          //s3中保存 s1中存在，s2中不存在的元素

s3=s1.symmetric_difference(s2)     //对称差集，s3中保存除s1 s2 共有元素外的元素

s1.difference_update(s2)

s1.symmetric_difference_update(s2)        //先找出差异值然后更新到s1中，即s1的值和以上例子中的s3的值一致

s3=s1.intersection(s2)            // 获取s1和s2的交集

s1.intersection_update(s2)    

s3=s1.union(s2)                    //获取2者的并集

 

s1.isdisjoint(s2)               //判断2者是否有交集

 

li=[11,22,33,44,111]

s1.update(li)     //加个可迭代的参数批量添加元素。注 可迭代的对象，即可使用for循环取值的对象，如列表

 

实用代码：

比较新旧字典的不同，并更新旧字典

new_set =set(new_dict.keys())

old_set=set(old_dict.keys())

 

remove_set=old_set.difference(new_set)

add_set=new_set.difference(old_set)

update_set=old_set.intersection(new_set)