输出与输入
数据类型
变量和常量
条件语句，循环语句
列表(list),元组(tuple)，字典(dict),集合(set)
函数
面向对象(类)
输出与输入：
输出：
1.print("…")这里面可以是单引号，可以没有括号(老版的)。
2.还可以连续输出，只需要在前一个输出结果加一个逗号就行：print“。。。”，“。。。”.
3.还可以输出表达式的结果print 4+2
4.可以输出不同类型的结果：print “你好：”,4+2。
输入：
自带一个raw_input()函数，并且可以把输入的结果放到变量当中：language=raw_input(“please input your best language:”),括号里为输入之前打印的话，但是它返回的是字符串类型，索引当我们想要其它类型的时候（比如说int类型），我们就可以a=int(input()).
数据类型
数据类型：整数，浮点数（小数），字符串：单引号或者双引号括起来的，布尔，空值
注意：对变量进行声明的时候不需要标注声明数据类型，系统会自动识别，比如说我声明一个整型的数等于十：a=10，而不是int a = 10。它与c++差别比较大。
1.整数之间运算结果是整数，整数与浮点数运算时结果是浮点数，但会出现四舍五入的情况。
2.转义字符：print(‘hello’ world’),这个时候里面的单引号和外面的冲突了，而这个时候想输出单引号，那么必须用转义字符\，双引号也是如此。\n表示换行，当我们要写多行时，就可以使用三个单引号。
3.布尔类型：True,False.
4.布尔运算：通过比较运算出来的值，比如说3>2就是一个True类型。
5.与或非：and，or，not
6.字符串：
常见方法：
center：通过在两边填充字符（默认为空格），让字符串居中。center（39）：通过填充字符，让字符串长度变为39
center（39，’’），填充字符变为’’。
find:在字符串当中查找字串，如果找到，就返回字串的第一个字符的索引，否则返回-1.
join:用于合并序列的元素成一个字符串：
seq=[‘1’,‘2’,‘3’,‘4’,‘5’]
sep=’+’
sep.join(seq)
最终变成’1+2+3+4+5’
lower：返回字符串的小写版本,x.lower()。
replace：将指定字串换成另一个字符串：replace(‘is’,‘hello’),is为字串，hello为替换字符串。
split：将字符串分解成一个序列：
‘1+2+3+4+5’.split(’+’)-------->[‘1’,‘2’,‘3’,‘4’,‘5’]
strip：将字符串开头和末尾的空白但是不包括中间的空白删除，并且返回删除后的结果。
字符串.strip()。
当然这个还可以指定删除哪些字符或者字符串，strip(’*’)。
变量和常量
1.变量：不仅仅时数字，还可以是各种数据类型：str=“你好”，其必须是数字，大小写英文和—的仁义组合。变量在定义是不能用数字或者特殊的字符开头。原理举例：定义一个字符串变量时，会在内存开辟一个空间，并且让该变量指向这个空间。
2.常量：就是不能被改变的量，比如说PI就是圆周率，它本身是不能被改变的。
条件语句，循环语句
1.if语句：if+条件+冒号+实现语句：if num>0: print(‘hello world’) //冒号后面最好换行并且缩进一格
2.else语句：else：实现语句
3.if else语句连续使用：
举例：if num>0:
…
elif num<0:
…
else:
…
需要注意缩进！！！！
4.更加复杂的条件语句：
a.比较运算符：相等运算符(==)，相同运算符(is)(注意这里的is运算符是检测两个变量是否相同，而不是相等，更加严谨)
成员资格运算符(in)：比如说name当中的n就是name当中的成员，即为n in name为真。
5.循环语句：
a.while语句：while+条件：
执行语句(执行语句之间缩进必须一样，并且比while缩进要多)
举例：while x<100:
print(x)
x++;
b.for语句：举例：
words = [“this”,“that”,…]
for word in words:
print(word)
c.跳出循环：break
列表(list),元组(tuple)，字典(dict),集合(set)
列表，元组，字典，集合都是python里面的数据结构，最基本的数据结构为序列。列表可以修改但是元组不可以。
1.序列：
a.索引：通过使用编号来访问各个元素，但是一次只能访问单个元素
举例：greeting =“hello”
我们可以通过greeting[0]来访问h字符，python里面的序列都是从零开始的，当然也有一些特殊之处，就是索引还可以为负数，比如说：greeting[-1]就是最后一个字符o。
b.切片：可以一次性访问特定范围内的多个元素。
举例：name=[1,2,3,4,5,6,7,8,9]
name[3:6]就是访问name序列当中的第四个到第六个元素，后一个索引6不在范围内。
注意：执行切片操作的时候，如果第一个索引指定的元素位于第二个指定元素的后面，结果就为空序列。
如果第一个索引位于序列开头，那么可以省略：name[:6]访问第一个到第六个元素。
c.序列相加：通过加法运算来实现序列拼接：[1,2,3]+[4,5,6]=[1,2,3,4,5,6].
d.序列乘法：当序列与数x相乘的时候，将会重复这个序列x次，比如说：[42]*5就是[42,42,42,42,42]
2.列表：
a.list函数：list(“hello”),直接建立一个[‘h’,‘e’,‘l’,‘l’,‘o’].
b.修改列表：直接找到索引赋值就可以了
举例：x=[1,1,1]
x[1]=2
那么x列表就会变成[1,2,1]了。
c.删除元素：使用del语句。
举例：names=[“Peter”,“Zam”,“Lisa”]
del names[1]
最终names变成[“Peter”,“Lisa”].
d.给切片赋值:
举例:name=list(“hello”)
name[2:]=list(“y”)
最终列表会变成：[‘h’,‘e’,‘y’]
此功能还可以实现插入：
number=[1,5]
number[1:1]=[2,3,4]
最终列表变成[1,2,3,4,5].
还可以实现删除：
举例：
number=[1,2,3,4,5]
number[1:4]=[]
最终列表变成[1,5]。
e.列表方法：
len():获得列表的长度，len(x)
append：将一个对象加到列表末尾，如：
lst = [1,2,3]
lst.append(4)
最终列表变成[1,2,3,4]，把4这个数加到了列表的后面。
clear:清空列表,如：
lst=[1,2,3]
lst.clear()
最终列表被清空，变成[]。
copy：复制列表,如：
a=[1,2,3]
b=a.copy()
于是我们就把a列表里面的内容复制到了b列表当中。
count：计算指定的元素在列表当中出现了多少次，如：
x=[1,2,3,4]
x.count(1)
表示1在count当中出现了一次。
extend：将多个值加到列表末尾，如：
a=[1,2,3]
b=[4,5,6]
a.extend(b)
于是a列表就变成了[1,2,3,4,5,6]。但是其与拼接不一样，其是直接修改列表，而不是创建一个新的列表，效率比拼接高。
index:在列表当中查找指定值第一次出现的索引，如，name.index(‘h’),就是查找h在name里面第一次出现的索引。
insert：将一个对象插入列表：
number=[1,2,3]
number.insert(1,‘four’)
列表变成了[1,‘four’,2,3]。
pop：从列表当中删除一个元素，默认为最后一个元素，并且返回该元素：
x=[1,2,3]
print(x.pop())
结果就是3，并且列表变成了[1,2]。
或者：
print(x.pop(0))
删去了第一个元素，结果是1，并且列表变成了[2,3]。
remove：删去第一个为指定值的元素。remove(指定值)
reverse：倒序。
sort()：把列表排序（不返回任何值，就是把列表给修改了），但是sorted可以：x.sort(),sorted(x).,默认为升序。
3.元组：
元组是不可修改的,tuple里面的元素可以是任何类型。
a.其实元组的创建很简单，就是把一些值用逗号隔开，然后元组就可以自动创建了：x=1,4，x就是一个元组。或者可以用小括号
b.turple函数：以一个序列作为参数，将其转换为元组，如果序列已经是元组，那么就原封不动的返回即可。
turple([1,2,3])------>(1,2,3)
turple(‘abc’)-------->(‘a’,‘b’,‘c’)
index：返回指定值的索引：x.index(元素)
注意：
定义一个空的tuple，可以写成(),但是空的tuple不是None，即为空值。
定义一个元素的元组时，要写成(x,)，而不能写成（x）
不可以改变tuple里面的成员，但是tuple成员本身可以改变：
s=(1,2,[1,2])
s[2]=“hello"会报错
s[2][1]=3不会报错表面上看，tuple元素的确改变了，但是其实变的不是tuple的元素，而是list里面的元素，tuple一开始指向的list并没有改成其他的list，指向还是原来的指向，我们可以称之为所谓的"不变”
tuple不可变，比较安全，尽量能用tuple替代list就替代list
4.dict字典：
字典由键和值组成，键-值对称为项。键与值之间用冒号隔开，用花括号括起来。
比如说{1:‘peter’,2:‘lisa’}就是一个字典。但是dict成员的数据顺序和我们定义的顺序不一定一样，我们删除项的时候只需要删除键。
a.dict不可以通过下表（索引）来访问，只能通过键。
b.用pop函数删除，x.pop(键)
c.修改键对应的值的时候，就是用键访问的时候赋值，但是键不能够改变，而且字典里的键是唯一的，不能重复。
x={1:‘a’,2:‘b’}
删除：x.pop(1)。
修改：x[1]=‘c’。
d.键必须可以hash，键是一个常量。
e.get方法：判断键是否存在：
x.get(1),键中是否有1，若不存在，则返回None。
x.get(1,“key not exist”)，若不存在，输出后面的提示信息。
f.对dict成员的key进行增加，删除操作的时候，dict的hash表的结构就会改变，成员的存储顺序会变化，在遍历的时候就会出现混乱，因为已经遍历过的成员可能再次被遍历。
比如说：
y={1:‘a’,2:‘b’}
for key in y:
y.pop(key)
print(key)
这样就会报错。
对于这种情况，咱们可以这样解决：
我们可以把dict成员的key取出来放在一个list或者其它容器当中，我们再遍历整个list，取出key，根据key去删除dict，这样就不会遍历经过删除后而改变的dict。
y={1:‘a’,2:‘b’,3:‘c’}
list =[]
for key in y:
list.append(key)
print(list)
for value in list:
if value==1:
print(y[value])
y.pop(value)
print(y)
5.set集合
1.定义和用法：
a.set和dict类似，它是一组key的集合，但是不存储value，它们两个key的属性是一样的，不可修改键元素，但是元素本身可以修改，和tuple差不多。
b.set的定义需要一个list作为输入集合：ss=set([2,3,4])
c.set的key是无序的，因此不可以通过下标访问，但是可以通过转化成list来访问。
d.可以通过add函数添加元素，也可以重复添加，但是重复添加的元素无效，就是说set里面无重复元素。
e.通过remove函数删除元素，如果不存在则抛出异常，如果不想让它抛出异常，我们可以使用dischard函数
f.pop函数也可以实现删除，但是方法不太一样，它是从上面依次删除。ss.pop()
2.set交集和并集计算：
ss1=set([1,2,3,4])
ss2=set([2,3,4,5,6])
ss=ss1&ss2---------------->交集运算，结果为{2，3，4}
ss=ss1|ss2--------------------->并集运算。
函数：
1.内置函数：
内置函数包括函数名，参数（注意参数类型），返回值(也可能没有返回值)。像这些内置函数都是python库里面自带的。
abs：绝对值函数：value=abs(-10)的结果就是10.
2.自定义函数：
1.自定义函数是我们自己根据需求所定义的函数。
2.我们定义一个这样的函数的时候需要使用def语句，并且一次写出函数名，括号，括号里面可以写参数，之后写冒号，然后在缩进块当中编写函数体，然后可以有返回值。
def myabs(value):
if value>=0:
return value
else:
return -value
注意缩进！！！！！
3.如果说函数体没想好怎么写，那么我们就可以在函数里面写一个pass。
3.高阶函数
可以接收函数作为参数的函数就是高阶函数
a.map函数： 接收一个函数 f 和一个 list , 并通过把函数 f 依次作用在 list 的每个元素上 , 得到一个新的 list 并返回
map(f,[1,2,3])
b.reduce函数：和map用法一样，但是f必须接收两个参数值，reduce()对list的每个元素反复调用函数f , 并返回最终结果值。
reduc可以用来求和。
c.filter函数：接收一个函数 f 和一个list , 这个函数 f 的作用是对每个元素进行判断 , 返回 True或 False , filter()根据判断结果自动过滤掉不符合条件的元素 , 返回由符合条件元素组成的新list，里面的函数必须为布尔类型的函数。
d.排序函数：sorted，可进行自定义，默认为升序排序。
sorted(iterable, key=None, reverse=False)，iterable为可迭代对象，key为进行比较的元素，reverse为升序和降序，False降序，True升序
类
1.类的定义：
class Style(object):
…
2.构造函数：
我们有一个固定的构造函数，所有的类都是如此：def init(self,…):
def init(self, name, sex):
self.name = name
self.sex = sex
3.析构函数：
类似于：def del(self,…):
4.属性定义：
属性可以直接定义，比如说，直接在class那一行下面写：name=“Peter”,这就相当于定义了一个name属性，这个相当于公有属性。
或者我们可以在构造函数里面定义，比如说：
def init(self, name, sex):
self.name = name
self.sex = sex
这里面就相当于定义了name和sex属性了，但是只能在类里面访问，相当于私有的。
5.方法定义：
定义格式：def 方法名(self,…):
def BMethon(self, args):
super(B, self).AMethod(args)
6.继承：
格式：class 子类(父类):
子类可以使用父类的方法，通过super来调用：
class B(A):
def BMethon(self, args):
super(B, self).AMethod(args)
