转换变量类型得到预期结果

random可以生成随机数

a = [1,2,3,4,5]

打乱排序 

在Python中

二进制表示方式以 0b 或者 0B 开头

八进制是 0o 或者 0O

十六进制是以 0x 或者 0X 开头

复数用j表示i： 3+5j

在Python里字符串属于一个不可变序列类型的对象类别，意味着这些字符串所包含的字符存在从左至右的位置顺序，而且他们不可以在原处修改。

Raw字符串在不想要转义字符串的前面加r        r"C:\My\new\Directory\file.exe"

三引号 可来写两行以上的字符串

Python3.x 有Byte字符串：b'Te\x01xt'       默认是使用Unicode的方式储存字符串                                              python2.x 有Unicode字符串 u'my\u0020text'  默认是使用Latin-1的方式储存字符串，因此不能识别中文。                             加上这句话 #-*-encoding=utf8-*- 才能正常使用中文。

\f是换页                                 \v是同一列换行

len()函数与c中不同，是所有的字符（包括\0）

'Hi!'*3                                 'Hi!Hi!Hi!'

a='0123456789'                           print(a[2:3])==>2                       print(a[2:])==>23456789                 print(a[:-1])==>012345678              

ord函数查看ASCII    python2.x中查看中文时，前面要加u  即ord(u'中')

a.replace('123','-') ==> 0---456789       a的值不会改变。

a=a.replace('123','-')   a的值才会改变

                             未来之巳

                           2018.5.21

Python中变量无类型

变量：一个系统表的元素，拥有指向对象的连接空间

对象：分配的一块内存，有足够的空间去表示他们所代表的值

引用：自动形成的从变量到对象的指针

对象的回收：因为对象是独立于变量的，当不再使用时回收。即a=3  再次赋值（a=3）时，对象3回收0.

共享引用：

当两个变量相互赋值（a=b）时，b的引用赋给了a,这时a与b共享了对象3.；当共享引用时，用了类似a+=2等等操作是会创造新的对象和引用。

列表的共享引用：                      List1=[1,2,3]                            List2=List1(共享引用)【改变List1的值会影响到List2的值】                          List2=List1[:]（复制列表）【改变List1的值不会影响到List3的值】

is 判断两个对象是否是同一个对象             == 判断两个对象是否相等

import sys                   syssys.getrfcount(元素)可查看元素被使用多少次（不会为零【因为自己也会引用到这个元素】）

位运算只能用于整数

type 显示数据类型

10<20<30 ==>> 10<20 and 20<30

Python 2.7 :

5/4=1

Python 3.x:

5/4=1.25

Python 数学函数

pow  幂函数

abs  绝对值

round 四舍五入（2.x中与预想一致（结果为浮点形式）  3.x中round(3.5)==>> 4(靠近偶数的方向取整且为整数形式)）

format 格式化输出（对小数）format(2.567,'0.2f')==>2.57           format(2,'b')==>'10'

int,bin,oct,hex,float 改变格式

cmp  比较（2.x 前面的数大时为1，相等为0，后面的数大为-1）

max,min 最大值与最小值

sqrt  平方根

引入math模块

fabs  绝对值

ceil（比给的数大的最小的整数）,floor（比给的数小的最大的整数） 取整

log 自然对数（自定义log(a,b)b为底）

log 底数为10的对数

modf 对浮点数分成小数部分和整数部分

引入random模块imporm random

random.random()生成0-1之间的随机小数

choice((多个元素))【元组】在这些元素中取随机值

sample((元组),取的数的个数)

shuffle 【列表】打乱顺序

getrandbits(bit数)显示整数

Decimal 模块（解决精度问题）

                              未来之巳

                             2018.5.17

add the line to your python source

#! add python path in this

e.g.:

#!/usr/bin/env python

make the script to a executable file

~:chmod +x *.py

===元组
定义：
nums = (value1,value2,value3)
特点：
与列表差不多但不可修改
 

=====字典
infor = {key:value,key2:value2}
#用键值对方式存储
infor={'name':'班长','addr':'北京','age':'18'}
print('%s %s %d'%(infor['name'],infor['addr'],infor['age']))
==字典中添加键值对
infor['newKey']=newValue
#在原key不存在的情况下，为添加，否则为修改
==字典中删除键值对
del infor['key']
#不存在就报错
#如果不确定该键值对是否存在
#使用
infor.get('key') #不存在就不显示信息，存在就显示值
.get()也是查询

list.items()取出的是一个元组
('key','value')
('key1','value1')

对于元组，可以使用分配赋值的方式
a,b=list.items()
a=key
b=value

 
==for循环中可以使用else
for temp in list:
else:
    代码……
#else中的代码一定会执行
#可以在for中使用break 直接结束for循环则else中的代码不会执行

=====列表

==插入
names = ['','',12,3.14]
#可存放不同类型元素
names.append('666')
#在原有列表最后添加元素
names.insert(0,'八戒')
#在指定索引插入数据，原来的元素后退
names2 = ['a','b','c']
name3=names+names2 #可以合并
names.extend(name3)
#会把指定列表合并到该列表中

==删除
list.pop()
#删除最后一个元素
list.remove()
names.remove('a')
#从左边删除指定内容
del names[0]
#按下标删除

==改
list[index] = values

==查
values in list
values not in list

#返回值为布尔型

###注意：列表经常用于存放相同的信息
###extend与append的不同：
extend是元素之间的合并
append是将一个列表当作一个元素插入到另一个列表中

=====列表

==插入
names = ['','',12,3.14]
#可存放不同类型元素
names.append('666')
#在原有列表最后添加元素
names.insert(0,'八戒')
#在指定索引插入数据，原来的元素后退
names2 = ['a','b','c']
name3=names+names2 #可以合并
names.extend(name3)
#会把指定列表合并到该列表中

==删除
list.pop()
#删除最后一个元素
list.remove()
names.remove('a')
#从左边删除指定内容
del names[0]
#按下标删除

==改
list[index] = values

==查
values in list
values not in list

#返回值为布尔型

###注意：列表经常用于存放相同的信息
###extend与append的不同：
extend是元素之间的合并
append是将一个列表当作一个元素插入到另一个列表中

====字符串
python中 内存分配取决于底层的编译器
查看内存占用字节数
len(变量)
组成新字符串
a='lao'
b='wang'
c=a+b #>>>c 'laowang'
d=100
e=200
f=d+e #>>>f 300
g='==='+a+b+'===' #>>>g '===laowang==='
h='===%s==='%(a+b) #>>>h '===laowang===' python3中字符串拼接可以使用引用的方式

==字符串下标
name = 'abcdef'
>>>name[2]
c
#字符串下标从0开始
IndexError:out of range下标越界
==取最后一个字母
name[len(name)-1]
name[-1]
==字符串切片
>>>name[2:5] #从2到5
'cde'
>>>name[2:-1] #从2到最后的前一位
'cde'
>>>name[2:] #从2到最后
'cdef'
==间隔一位，切片
>>>name[2:-1:2] #从2到最后的前一位，并且隔一位一取
'ce'
#name[起始位置:终止位置:步长]
默认步长为1
==逆序
>>>name[-1:0:-1]
fedcb
>>>name[-1::-1]
fedcba
>>>name[::-1]
fedcba
#起始点与截止点根据步长有关

==常见函数
myStr = "hello world itcast and itcastxxxcpp"
myStr.这时候按TAB会显示字符串的常见操作
>>>myStr.find('world')
6 #返回开头字母的下标
>>>myStr.find('dog')
-1 #找不到为-1
从左边开始找
>>>myStr.rfind('itcast')
23

==替换
>>>myStr.replace('world','WORLD')
hello WORLD itcast and itcastxxxcpp
>>>myStr
hello world itcast and itcastxxxcpp #字符串为不可变类型，仅返回新字符串，旧值不变
replace('','',num) #替换几个

==切割
>>>myStr.split()
myStr.split()#默认可以将空格与转义字符删掉并切割字符串，返回list
再使用.join拼接回字符串

==开头大写小写
myStr.capitalize() #小写
myStr.title() #大写

==判断以什么开头，以什么结尾
file_name = 'xxx.txt'
file_name.endswith('.txt')
file_name.startswith('wang')
#返回值为布尔型

==大小写转换(所有)
.lower
.upper
>>>

====字符串
python中 内存分配取决于底层的编译器
查看内存占用字节数
len(变量)
组成新字符串
a='lao'
b='wang'
c=a+b #>>>c 'laowang'
d=100
e=200
f=d+e #>>>f 300
g='==='+a+b+'===' #>>>g '===laowang==='
h='===%s==='%(a+b) #>>>h '===laowang===' python3中字符串拼接可以使用引用的方式

==字符串下标
name = 'abcdef'
>>>name[2]
c
#字符串下标从0开始
IndexError:out of range下标越界
==取最后一个字母
name[len(name)-1]
name[-1]
==字符串切片
>>>name[2:5] #从2到5
'cde'
>>>name[2:-1] #从2到最后的前一位
'cde'
>>>name[2:] #从2到最后
'cdef'
==间隔一位，切片
>>>name[2:-1:2] #从2到最后的前一位，并且隔一位一取
'ce'
#name[起始位置:终止位置:步长]
默认步长为1
==逆序
>>>name[-1:0:-1]
fedcb
>>>name[-1::-1]
fedcba
>>>name[::-1]
fedcba
#起始点与截止点根据步长有关

==常见函数
myStr = "hello world itcast and itcastxxxcpp"
myStr.这时候按TAB会显示字符串的常见操作
>>>myStr.find('world')
6 #返回开头字母的下标
>>>myStr.find('dog')
-1 #找不到为-1
从左边开始找
>>>myStr.rfind('itcast')
23

==替换
>>>myStr.replace('world','WORLD')
hello WORLD itcast and itcastxxxcpp
>>>myStr
hello world itcast and itcastxxxcpp #字符串为不可变类型，仅返回新字符串，旧值不变
replace('','',num) #替换几个

==切割
>>>myStr.split()
myStr.split()#默认可以将空格与转义字符删掉并切割字符串，返回list
再使用.join拼接回字符串

==开头大写小写
myStr.capitalize() #小写
myStr.title() #大写

==判断以什么开头，以什么结尾
file_name = 'xxx.txt'
file_name.endswith('.txt')
file_name.startswith('wang')
#返回值为布尔型

==大小写转换(所有)
.lower
.upper
>>>

==动态语言
静态语言:运行前先编译，运行过程中不能修改
动态语言:直接运行

==动态添加属性及方法
class Person(object):
    def __init__(self,newName,newAge):
        self.name=newName
        self.age=newAge

laowang=Person('laowang',100)
laowang.addr='bj'#对象动态添加属性

Person.num=100 #给类动态添加属性

def run(self):
    print('run')

laowang.run=run
laowang.run(laowang) #在类外部动态添加的方法，需要手动传参

优化：
import types
laowang.run=types.MethodType(run,p1)
laowang.run()

@staticmethod
def test():
    pass
Person.test=test#添加静态方法

@classmethod
def printNum(cls):
    pass
Person.printNum=printNum #添加类方法

==__slots__
由于python是动态语言，可以任意添加属性和方法
那么，有没有一种方法，让实体只能拥有我们定义好的属性呢？
class Person(object):
    __slots__=('name','age')
限制通过Person类创建的任意对象，只能拥有name、age属性
添加其他属性会报错

Python2.x 的一般整数是64字节（符号占一位），超过的后面有L（长整数）【特殊的两个2**62+2**62的结果能为整数】

Python3.x 没有这两种整数，只有一般整数

二进制  ：0B 或0b 开头

八进制  ：0O 或0o 开头

十六进制：0X 或0x 开头

将i转化进制输出(文本形式)

二进制  ：bin(i)

八进制  ：oct(i)

十六进制：hex(i)

int(str,base)：非十进制的文本转化为整数

str是文本形式的数字，base表示进制（最多支持到36）

浮点数 用64字节来存储，精度为17位

Python 2.x 和3.x

输出要一致的话

用print repr (1.0/6)

Python 表示复数是

1.用complex(3,5)

2.3+5J

3.3+5j

分数 Fraction(4,5) 五分之四

无穷大 float('inf')

无穷小 float('-inf')

非数字 float('nan')

身份运算符：is,is not

当两个数据完全相同时才为Ture（is）

#注释

1 and 2 显示的是后面的2

1 or 2  显示的是前面的1

优先级

1. 乘方（**）

2.非（～），符号（+）和（-）

3.乘、除、取模、整除

4.加减

5.按位移

6.按位与

7.按位或（|），按位异或（^）

8.关系（<= >= < >）

9.== !=（<>）

10.赋值

11.is

12.in

13.and or not

Python可分为 2.x 和3.x 两个版本 各有不同 3不向下兼容

Python语法简洁，无需编译开发效率高，可以执行强 

Python运算大数据的时候不会溢出

Python不能使用{}表示语句开始和结束而是使用缩进在使用多行语句时可以用一个/

Python注释 一个#开头其余的此行都是而""" ..."""可以注释多行

转义字符\字符

 list1+list2   两个列表顺序结合

list*3  列表1重复三次

for i in list:print  i 打印列表内容

3 in list  判断3是否在列表中

list1  index(1) 查找列表第一个为1的对象的位置

list1.count(1)  列表中对象为1的个数

list1[x:y] 取第x到第y的对象 重新建表

len(list1):list1的对象个数

from fractions import Fraction

import Fraction不行

导入后才能用

整<fraction<浮点<complex

移位只能用于整数

1 and 2 ->2第二个数字

0 and 2 ->0

0 or 3  ->3非零的

3 or 2 ->第一个数字

在cmd中打powershell可以进入ps

float(Fraction(4,5)) is 08 是false

type(float(Fraction(4,5))

x<y>z x<y and y<z有false不继续

int(1.9)=1

import math

from math import *

abs(-10)=10

math.fabs(-10)=10.0

round四舍五入

3是靠近偶数四舍五入

math.ceil(1.5）=2

random.random()从0到1之间取

random.choise((1,2)) or ([])

random.sample((1,2),个数)

结果为列表

random.shuffle洗牌

（）元组，[]列表，打乱只能用列表

n位二进制随机数

random.getrandbits(个数n)

math.modf(2.5)分离

用Decimal更准确地进行浮点数运算

format除去输出的进制头

36位1-9，a-z

//留整数，3//6结果为0

<>不等于

先对a的补码取反再显示它的补码

1 is 1完全相同才真

数字类型

整数

浮点数

复数  complex（）

二进制 0b或者0B开头

八进制 0o或者0O开头

十六进制0x或者0O开头

bin(1)讲1转化为二进制