关于Python的一些学习总结

一、类型

1.变量没有类型，数据有类型

例：num = 1  ---->num是没有类型的，1是int类型

二、格式化输出

2.name = "张三"

　 age = 18

     print("我是" + name + ",今年" + age + "岁")    #这样会报错，用＋进行拼接时，正数和字符串不能拼接

3.占位符

%c      字符
%s 字符串
%d   有符合的十进制整数
%u

无符号十进制整数
%o

八进制整数
%x

十六进制整数（小字母0x）
%X

十六进制整数（大写字母0X）
%f

浮点数
%e

科学计数法（小写'e'）
%E

科学计数法（小写'E'）
%g

%f和%e的简写
%G

%f和%E的简写

三、运算符

1.

/ 除 得到结果是浮点数

//取整除  不是四舍五入 是取比结果小的第一个整数

%取余

**指数

2.复合运算符(在进行符合运算的时候，不论什么情况，都首先算等号右边的式子)

+=

-=

*=

/=

**=

//=

3.常用数据类型转换(input()输入的是字符串)

int(x)

将x转换成一个整数
float(x)

将x转换成一个浮点数
complex(real,[,imag])

创建一个复数，real为实部，imag为虚部
str(x)

将x转换成一个字符串
repr(x)

将x转换成表达式字符串
eval(str)

用来计算在字符串中的有效的python表达式，并返回一个对象
tuple(s)

将序列s转换成一个元组
list(s)

将序列s转换成一个列表
chr(x)

将一个整数转换成一个Unicode字符
ord(x)

将一个字符转成一个ASCII整数值
hex(x)

将一个整数转成一个十六进制的字符串

4.切片

name = "abcdef"
print(name[0:3])

取下标0-2的字符
print(name[0:5])

取下标0-4的字符
print(name[3:5])

取下标3-4的字符
print(name[2:])

取下标2之后到最后的的字符
print(name[1:-1])

取下标1开始到最后第二个的字符

5.字符串常见的操作

find（str，0，len(mystr)）  查找字符串中是否出现str字符，从下标为0开始到最后;没有找到则打印-1
index（str，0，len(mystr)）

跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
count()

返回 str在start和end之间 在 mystr里面出现的次数
replace()

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
nystr.solit(str,2)

以 str 为分隔符切片 mystr，2则表示 只分割几个字符串
capitalize 把字符串第一个字符大写
title

把字符串的每个单词首字母大写
startswith 检查字符串是否以"str"开头，是则返回True
endswith

检查字符串是否以"str"结尾，是则返回True
lower

将字符中所有大写转换成小写
upper

将字符中的所有小写转换成大写
ljust

返回一个原字符串左对齐，并使用空格填充至剩下长度的新字符串
rjust

返回一个原字符串右对齐，并使用空格填充至剩下长度的新字符串
center

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
lstrip

删除str左边的空白字符
rstrip

删除str左边的空白字符
strip

删除mystr字符串两端的空白字符
rfind

从右查找与find差不多
rindex

类似于 index()，不过是从右边开始.
partition 

把mystr以str分割成三部分,str前，str和str后
rpartition  类似于 partition()函数,不过是从右边开始.
splitlines

按照行分隔，返回一个包含各行作为元素的列表
isalpha

如果 mystr 所有字符都是字母 则返回 True,否则返回 False
isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.
isalnum

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.
join

mystr中每个字符串后面插入str构成一个新的字符串

 

6.列表的常见操作（列表是有序的，可以重复，可变）

添加操作：

list_1.append("asd")

直接添加到最后

list_1.extend([1,2])

将另一个集合中的元素逐一添加到列表中

list_1,insert(index,obj)

index表示添加到指定下标处，obj代表要添加的内容

改操作：

list_1[1]

根据对应的位置进行修改

查：

in（存在）,如果存在那么结果为true，否则为false

not in（不存在），如果不存在那么结果为true，否则false

index和count与字符串中的用法相同    a.index('a',1,4)按照索引1到索引4查找a出现的位置（这个位置还是原理的索引）

删除操作：

del：根据下标删除　

pop：删除最后一个元素

remove：根据元素的值进行删除

 

排序：sort reverse

sort是将list按照特定的顺序进行排列参数reverse=True可改为倒序，由大到小，

reberse是将list逆置

 

7：元组（元组的元素是不能修改的）

index和count与字符串和列表中的用法相同

8：字典（无序可变）只有不可变的数据类型才能作为字典的键

若访问不存在的键值时则会报错，

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

添加操作：

1.根据索引访问不存在的元素会报错

2.如果在使用 变量名['键'] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素

demo:添加新的元素

删除操作：

del

del  info["name"]

clear()

　清空整个字典，但是字典本身还存在
len(dic)

测量字典中，键值对的个数
dic.keys

返回一个包含字典所有KEY的列表
dic.values

返回一个包含字典所有value的列表
dic.items

返回一个包含所有（键，值）元祖的列表
dic.has_key

dict.has_key(key)如果key在字典中，返回True，否则返回False

遍历字典的元素

dict = {"name":"zhangsan","sex":"nan"}
for item in dict.items()

print item
>>('name','zhangsan')
>>('sex','nan')

遍历所有键值对

dict = {"name":"zhangsan","sex":"nan"}
for k，v in dict.items()

print （k，v）
>>name,zhangsan
>>sex,nan

实现带下标的索引遍历

>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
...     print i, chr
...
0 a
1 b
2 c
3 d
cmp？python中才有

cmp(item1, item2) 比较两个值
 

关于引用：

使用1：不可变类型，修改形参，不影响实参

使用2：可变类型作为实参

修改则改变实参

使用3：可变类型作为实参时，在函数里为形参重新复制

结果：可变类型作为实参，如果为形参重新复制，修改形参不影响实参

关于Python的一些总结
希望自己以后在学习Python的过程中可以边学习边总结，就自己之前的学习先做以总结，之后将不断总结更新。

为什么选择Python
经常会有同学问我为什么选择Python。我很喜欢这门语言，因为它的简洁灵活，易学，易读，可移植并且功能强大。

高级

可以说，每一代编程语言的产生，我们都会达到一个新的高度。从汇编语言，到C Pascal等，伴随着C语言的诞生，产生了C++、Java这样的现代编译语言，之后有了强大的可以进行系统调用的解释性脚本语言Python、 Perl...
比如Python中就有一些高级的数据结构，列表和字典就是内建于语言本身可以直接使用的，在核心语言中提供这些重要的构建单元，可以缩短开发时间和代码量，产生可读性更好的代码。

面向对象

Python是面向对象编程

内存管理器

C 或者 C++最大的弊病在于内存管理是由开发者负责的。所以哪怕是对于一个很少访问、修改和管理内存的应用程序,程序员也必须在执行了基本任务之外履行这些职责。这些加诸在开发者身上的没有必要的负担和责任常常会分散精力。
在 Python 中,由于内存管理是由 Python 解释器负责的,所以开发人员就可以从内存事务中解放出来,全神贯注于最直接的目标,仅仅致力于开发计划中首要的应用程序。这会使错误更少、程序更健壮、开发周期更短。

解释性和编译性

Python 是一种解释型语言,这意味着开发过程中没有了编译这个环节。一般来说,由于不是以本地机器码运行,纯粹的解释型语言通常比编译型语言运行的慢。然而,类似于 Java,Python实际上是字节编译的,其结果就是可以生成一种近似机器语言的中间形式。这不仅改善了 Python的性能,还同时使它保持了解释型语言的优点。

Python为什么运行速度相较于C语言慢

因为Python等动态语言每一个简单的操作都需要大量的指令才能完成。Python是动态语言，变量只是对象的引用，比如对于一个简单的操作：a+b，在C语言中只需要一个机器指令ADD就好，而对于Python而言，变量a和b本身没有类型，而它们的值有类型，所以在相加之前需要先判断类型，之后，读取数值，相加，生成一个新对象，将运算结果存入，返回对象，当然，可能还会考虑内存溢出等问题。

Python基础
数据类型

python中的数据类型可以分为：字符串、布尔类型、整数、浮点数、数字、列表、元组、字典和日期。

字符串

不可变对象，可使用单引号，双引号扩起来表示单行字符串，使用三引号表示多行字符串，在三引号可以自由的使用单引号和双引号。

ASCII码

字符串比较特殊的是编码问题　我们知道，计算机是美国人发明的，最初只有127个字母被编码到计算机中，包括大小写字母、数字和一些符号，这个编码表被称为ASCII码表。

Unicode

要处理一个中文显然一个字节是不够用的，又不能和ASCII码冲突，因此中国制定了GB2312编码。而全世界有很多的语言，在多语言混合的文本中，显示出来的话一定会有乱码，因此，Unicode应运而生，它将所有语言统一到一套编码中，就不会有乱码问题了。ASCII码用一个字节表示了一个字符，而Unicode用两个字节表示一个字符。以Unicode表示的字符串用u'...'表示。

UTF-8

经常在.py文件的开头写的"#coding:utf-8”是什么意思？我们知道Unicode编码要比ASCII编码多一倍的存储空间，在存储和传输上会十分的不划算，如果写的文本全是英文的话，使用Unicode编码就十分浪费。于是UTF-8编码出现了，UTF-8编码是把一个Unicode字符根据不同的数字大小编码成1-6个字节，并且可以将ASCII码看成是UTF-8的一部分。

编码解码

在Python2.7中，操作系统给它什么编码的字符串，它就接收啥格式的字符串，默认的格式与使用的格式不同，就会出现各种错误。
解决方法：
1.知道系统所使用的编码格式
2.把获取的页面先用系统格式解码，然后在编码为utf8格式
3.你的脚本中统一使用uft8编码
4.处理结束，把你的字符串先utf8解码，然后系统格式编码。
Python中，通常使用decode()和encode()进行解码和编码。

布尔类型

一个布尔值只有True和Flase两种值

整数

包括整数和负整数。

浮点数

就是小数　整数和浮点数在计算机内部的存储是不同的　整数的运算永远是精确的　而浮点运算可能有四舍五入的误差　

列表List

list是一个是一个可变的有序表，是Python内置的一种数据类型，可以随时添加、删除、替换其中的元素。
Python中的列表就是一个迭代器，我们知道Python是使用C编写的，那么list的内部实现是怎样的呢？Python中的列表是基于PyListObject实现的，PyListObject是一个变长对象，在内部通过一些方法维护列表的地址，进行内存管理等实现列表的功能。

元组Tuple

除了元组以外的另一种有序表称为元组tuple,但是tuple一旦初始化便不能修改，在定义时，tuple的元素就被确定了。为什么要引入tuple呢？因为tuple不可变，所以代码更为安全，能用tuple代替list的情况就尽量使用tuple。
由于元组是不可变的，因此修改元素操作是非法的，但是可通过对元素进行连接组合，比如:tuple3 = tuple1 + tuple2。
使用del语句可删除整个元组。

字典Dict

Python内置了字典，使用key-value存储，具有极快的查找速度。和list相比，查找速度要高很多。
为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字，无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。
dict的初始化如下：

a = {}
a['A'] = 1
Dict和List的区别：Dict的查找速度和插入速度都是极快的，不会随着key的增加而增加；但dict要占用大量的内存，内存浪费多。
Dict是不可变对象，因为使用key来计算value的存储位置，为了保证结果的正确性，作为key的对象不能变，可使用字符串、整数等不可变的对象作为dict中的key。

结合Set

set和dict类似，也是一组key的集合，但是不同的是在set中没有重复的key。

可变和不可变

综上所述，Python中的不可变对象有：字符串、整数、元组；可变对象有：列表，集合，字典。
对于可变对象，比如list,对list进行操作，list内部的内容是会变化的，而对于不可变对象，比如str,使用replace()方法，虽然可以更改值，但是变量的值并不会发生改变，为什么呢？
比如：

#coding:utf-8

a = 'abc'
b = a.replace('a','A')
print b
print a

a是变量，而'abc'才是字符串对象，为什么a的值在执行完上述代码之后还是'abc',是因为a本身是一个变量，指向的对象是'abc',调用方法replace是作用在字符串对象'abc'上的，但并没有改变'abc‘的内容，只是新创建了一个对象并赋值给b变量。
对于不可变对象，调用自身的任意方法，并不会改变对象自身的内容，这些方法会创建新的对象并返回，保证了不可变对象本身是永远不可变的。

传值还是传引用

Python在参数传递时遇到的一个有趣的问题是：函数的传参是传值还是传引用？
对于不可变对象作为函数参数，相当于C系语言的值传递；
对于可变对象作为函数参数，相当于C系语言的引用传递。

高级特性
迭代器

Python中的迭代器是什么呢？
迭代器是访问集合元素的一种方式，迭代器的对象是从集合的第一个元素开始访问，直到所有的元素访问完结束，迭代器只能前进而不能后退。
对于遍历支持随机访问的数据结构（tuple,list),迭代器相比于for循环并无优势，因为迭代器丢失了索引值。但对于无法随机访问的数据结构，迭代器是唯一的访问元素的方式。
迭代器不要求事先准备好整个迭代过程中的所有元素，迭代器仅在迭代到某个元素时才计算该元素，迭代器仅仅在迭代到某个元素时才计算该元素，在这之前或之后，元素可以不存在或者被销毁，这个特点使得迭代器特别适合用于遍历一些巨大的或是无限的集合。
迭代器中有两个基本的方法：
next方法：返回迭代器的下一个元素
__iter__方法：返回迭代器对象本身。

生成器

带有yield的函数在Python中被称为生成器。yield就是将函数变成了一个生成器，函数执行过程中使用yield就好像是用yield将执行中断多次，每次中断都会通过yield返回当前的迭代值。
当数据量较大时，使用生成器的效率更高。

装饰器

函数是一个对象，函数对象也可以被赋值给变量，所以，通过变量也能调用该函数。在代码运行期间动态增加功能的方式，称为装饰器。使用Python的@语法，把装饰器置于函数的定义处。

元类

类是用来描述如何生成一个对象的代码段，在Python中，类同样是一个对象，只要使用class关键字，Python解释器在执行的时候就会创建一个对象。这个对象自身拥有创建对象的能力，所以它是一个类，但它本身还是一个对象，因此，可以实现以下操作：可以将它赋值给一个变量、可以拷贝它、可以为它增加属性、可以将它作为函数参数进行传递。
这也是动态语言和静态语言最大的不同，函数和类的定义，不是编译时定义的，而是运行时动态创建的。也就是在Python中，可以动态的创建类，类也是对象，这就是使用关键字class时Python在幕后做的事情，这些都是通过元类实现的。
那么到底什么是元类呢？
元类就是用来创建类的东西，创建类就是为了创建类的实例对象，但是我们知道类就是对象，元类就是用来创建这些类（对象）的，所以元类就是类的类。
元类是创建类这种对象的东西，可以将元类称为类工厂。
元类的主要用途是创建API。

闭包

Python中的闭包是什么？
如果在一个内部函数里，对在外部作用域的变量进行引用，那么内部函数就被认为是闭包。用Python的语言介绍就是，调用一个函数A，这个函数A返回了一个函数B给你，这个返回的函数B就叫做闭包。
装饰器就是一个闭包。