http://www.cnblogs.com/yuanchenqi/articles/5782764.html

一、变量

　　1、定义：变量用于存储要在计算机程序中引用和操作的信息。他们还提供了一种以描述性名称标注数据的方法，所以我们的程序可以被读者和我们自己更清楚地理解。将变量视为容纳信息的容器是有帮助的。它们的唯一目的是将数据标记和存储在内存中。 然后可以在整个程序中使用此数据。

　　2、声明变量：name="alex"

　　　　　　  上述代码声明了一个变量，变量名为： name，变量name的值为："Alex Li"

　　3、变量定义规则：

• 变量名只能是 字母、数字或下划线的任意组合
• 变量名的第一个字符不能是数字
• 以下关键字不能声明为变量名
  [‘and‘, ‘as‘, ‘assert‘, ‘break‘, ‘class‘, ‘continue‘, ‘def‘, ‘del‘, ‘elif‘, ‘else‘, ‘except‘, ‘exec‘, ‘finally‘, ‘for‘, ‘from‘, ‘global‘, ‘if‘, ‘import‘, ‘in‘, ‘is‘, ‘lambda‘, ‘not‘, ‘or‘, ‘pass‘, ‘print‘, ‘raise‘, ‘return‘, ‘try‘, ‘while‘, ‘with‘, ‘yield‘]

　　4、变量的赋值

二、缩进

　　缩进就是控制块，官方建议空四个空格，在很多语言里都是通过大括号来实现的，但是Python是通过空格

三、注释

　　单行注释：#

　　多行注释：""" """或‘‘‘ ‘‘‘

四、运算符

　　1、算数运算符 +　　-　　*　　/

　　2、赋值运算符 =　　+=　　-=　　*=　　/=

　　3、比较运算符 ==　　>=　　<=　　!=　　>　　<　　（一定是布尔值，用于循环）

　　4、逻辑运算符 and（与）　　or（或）　　not（非）

　　5、关系运算符 in　　not in　　（返回值是布尔值）

　　　　　　　　　例：print(2 in [1,2,3]

　　　　　　　　　　　True

　　6、位运算符

五、数据类型

　　1、定义：计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种

　　所有的数据类型一定可以划分为两种：

　　　　可变数据类型：列表，字典

　　　　不可变数据类型：整形，元组，字符串

　　　　不可变数据类型如下图：

　　　　再比如：i=1（在内存中创建一个数据类型）

　　　　　　　　i=2（并不是覆盖1，而是开辟一块新的空间，写上2）　　

　　2、数字（整形，浮点型，布尔类型）

　　整形

　　Python3中整形(int)就是长整型，在2.x版本中才有区分

　　浮点型（float，double）

　　科学计数法，是为了节省空间，比如无线循环和不循环小数如果一直存在去电脑会崩溃

　　精度要求非常高的话使用double

　　例：0.000123=1.23e^(-4)

　　布尔值

　　True=1，False=0，二者可进行运算，True+False=1

　　3、字符串（string）

　　创建2种（表达式和关键字）：表达式：s="zhongguo"

　　　　　　　　　　　　　　　  关键字：s=str("zhongguo")#涉及到类

　　字符串操作：

　　　　查找  []  [:]   #序列都可以进行切片，如字符串列表元组

　　　　去空：strip()#把字符串的开头和结尾的空格和制表符还有换行符去掉，括号里可以加参数

　　　　拼接：s="hello"+"world"+"I"+"am"+"python"(拼接次数多的话，效率要低，因为字符串是不可变的，显示helloworld申请一块内存空间，然后又是helloworldI申请一段内存空间，然后又是helloworldIam申请一断内存空间，一次类推)

　　　　　　   "".join(["a","b","c"])#join是将列表拼接成一个字符串，join参数一定是列表，列表里一定要放字符串，数字不能拼接，不是一个类型的不能拼接,""中可以加*，空格之类的其他东西

　　　　分割：split()，正好与join相反是把字符串分割成一个列表,参数只要字符串中有的都可以加，还有最大分个数split（,）逗号后边可以规定分割次数

　　　　　　　splitlines是以换行符为分隔符的如果末尾有\n的话不会显示，但split会显示

　　　　find(找不到返回-1)

　　　　"hello world".find("l")#打印后返回2

　　　　"hello world".find("l",3)#打印后返回3

　　　　index（找不到报错）

　　　　"hello world".index("l"，4)#返回后打印9

　　　　replace

　　　　"hello world".replace("world","python")#完全匹配，必须一对一匹配上 

　　　　s="hello world"

　　　　print(s.replace("world","python"))------------->hello python

　　　　print(s)------------------------------------------>hello world

　　　　因为字符串是不可变的，所以hello python是开辟了一块新的空间，之前的s还是指向hello world，而后边讲到的append针对的类型是可变的，是直接对列表（只举列表这一个例子）进行修改，没有返回值，也就意味着并没有开辟新的空间，直接打印原列表即可

　　　　居中显示：print("hello world".center(50,"*"))#居中显示总共50个字符，不够的用*补上

　　　　　　　　　print("hello world".ljust(50,"*"))#靠左显示，右边用*补全，总共50个字符

　　　　字符串的格式化输出：

　　　　　"hello %s"%"sb"---------->print后输出hello sb

　　　　　%s，给字符串占位　　%d，给整形占位　　%f，给浮点型数据占位，%.4f小数点后保留四位（占四位）

　　　　　"hello {0},his age is {1}".format("alex",34)#按索引位对应

　　　　　"hello {name},his age is {age}."format(name="wusir",age=30)#通过键值对（推荐）

　　　　　"hello {name},his age is {age}."format_map({"name":"agon","age"=33})#通过字典

　　　　关于数字判断：isdecimal(),isdigit(),isnumeric()--->返回True或者False

　　　　　isnumeric中1，一，I，壹都可以识别

　　　　大小写:

　　　　print("hello world".capitalize())----->Hello world

　　　　print("hello world".title())------------>Hello World

　　　　print("HEllO world".casefold())------->hello world

　　　　print("HEllO world".lower())------->hello world

　　　　expandtabs

　　　　"HELLO\tworld".expandtabs(20)更改\t的空格数

　　　　zfill：

　　　　print("hello world".zfill(50))#其他位置都补0，内容右对齐

　　4、列表  可迭代对象，能够进行for循环的就是可迭代对象

　　创建：l=[1,"hello",[4,5],{"name":"egon"}]

　　　　　l2=list([1,23,3])

　　　　　查：切片[:]

　　　　　增：append()#可以追加字符串和列表，追加到最后，只能添加一个，不能添加多个

　　　　　　　print(l2.append("yuan"))#返回None因为列表为可变的，没有开辟新的空间，直接在原来的结果上进行了添加

　　　　　　　extend()#可以进行多个添加，如12.extend([7,8])如果是多序列的话参数必须是列表形式

　　　　　　　insert(2,66)#指定位置进行插入，插入的66索引值为2

　　　　　删：l2.pop(1)#pop参数为索引值，返回删掉的值

　　　　　　　l2.remove(23)#不知道索引值，通过内容删除

　　　　　　　del 12[2]#最霸道的删除

　　　　　　　del l2#可直接删掉列表　　　del l2[1,3]#可以分段删

　　　　　改：l2[0]="yuan"

　　　　　清空：l2.clear()#清空就是把里面的值全清空，效率低

　　　　　　　　l2=[]#（推荐）与上面的不一样，这个是把l2重新指向了一个新的地址，所以和上面的内存地址肯定不一样

　　　　　计数：l2.count(3)#返回值是1，判断列表里有几个3

　　　　　长度：len(l2)#返回值是3，判断l2中有几个元素

　　　　　排序：sort　　l3=[3,1,56,34]

　　　　　　　　　　　　l3.sort()#.方法，默认reverse=False要从大到小排:l3.sort(reverse=True)

　　　　　　　　　　　　print(l3)

　　　　　　　　sorted   print(sorted(l3))#函数方法

　　　　　拷贝：深拷贝和前拷贝

　　5、字典（哈希算法可哈希就是可以进行哈希算法 反之就是不可以 可以进行哈希算法的数据就是不可变类型的，如果是不可变的，在对对象本身操作的时候，必须在内存的另外地方再申请一块区域(因为老区域#不可变#)，老的区域 就丢弃了(如果还有其他ref，则ref数字减1，类似unix下的hard-link)。如果是可变的，对对象操作的时候，不需要再在其他地方申请内 存，只需要在此对象后面连续申请(+/-)即可，也就是它的address会保持不变，但区域会变长或者变短。

）无序的

　　　　Python中唯一具有映射关系的数据类型，字典的查询速率要远高于列表，好比一页一翻得找和找到对应的页码直接找页码，但是字典的存储空间较大，比列表多了一张映射表，总之，是用空间取换取时间

　　　　创建：d={"name":"alex","name":"egon"}#打印结果会以后面的结果为准，就是前边的被覆盖了，白写。键唯一且为不可变数据类型，如元组、字符串、整形

　　　　查：d["name"]

　　　　　　d.get("name",None)#推荐，如果字典里没有的话返回None，可以换成一些其他的东西比如False

　　　　　　for i in dict循环遍历的是字典的key

　　　　　　for i in dict：

　　　　　　　　print("%s---->%s"%(i,d[i]))#格式化输出

　　　　增：d["gao"]="luchuan"

　　　　改：d["name"]="yuan"

　　　　删：d.pop("1")#返回删掉的value值

　　6、集合set  两个功能：去重，关系测试。 可变数据类型

　　　  set集合内元素一定是不可变数据类型

　　　  关系测试：s1={"hello",1,2,3}

　　　　　　　　  s2={1,2,("a","b")}

　　　　求并集：print(s1.union(s2))

　　　　　　　　print(s1|s2)#顺序没关系　　　　

　　　　求交集：print(s1.intersection(s2))

　　　　　　　　print(s1&s2)

　　　　求差集：print(s1.difference(s2))#s1中有的，s2中没有的

　　　　　　　　print(s1-s2)

　　　　　　　　print(s2.difference(s1))#s2中有的，s1中没有的

　　　　　　　　print(s2-s1)

　　　　求对称差集：print(s1.symmetric_difference(s2))#互相都没有的

　　　　　　　　　　print(s1^s2)　　　

　　7、元组tuple　　（不能进行修改操作）

　　　　查： 切片 [:]　

python基础篇