lesson-1
脚本解释型语言的内部机制
在运行脚本之前，得到结果之后
1.Python先将脚本编译成字节码 文件(pyc,pyo)
2.python虚拟机解释器解释并运行字节码文件
编译型语言的内部机制
1.先将源代码编译成机器码文件，生成可执行文件
2.运行可执行文件
如果代码中出现中文，一定要在代码首行 #coding=utf-8
在代码块中，三引号可以用作注释comments
Python是动态语言，是弱类型语言，即执行过程中确定变量的数据类型，分配内存。而想C，C++，java等都是静态语言，强类型的，在编译期间必须明确数据类型。在声明变量时必须明确指定数据类型。否则报错。
注明程序主体：if __name__=='__main__':
变量与引用，标签的理解：d=4
我是变量d，因为字符串对象‘4’赋值到我这里来了，我被创建出来了；我这里存了一个字符串对象的位置（地址），就是‘4’的位置；我没有存字符串对象‘4’的数据，这就是引用；
我是字符串对象‘4’，我被创建出来了，我赋值给了变量d
多重赋值：
a,b,c = "str1","str2",4中文字符串长度判断问题：(在Python 3.x中已经改为统一了，不再出现下述问题)
a='哈'
len(a)=3
a=u'哈'
len(a)=1
b='哈哈哈'
c=b.decode('utf-8')
print(c)字符串与转义字符\反斜杠 ，及 r
>>> print('hello\n')
hello
>>> print('hello\n world')
hello
world
>>> print('hello\\n world')
hello\n world
>>> print(r'hello\n world')
hello\n world
>>> print(r'hello\\n world')
hello\\n world
>>>lesson-05 Python数据类型
2.数据类型的组成
组成3部分。
身份 id方法来看一看他的唯一标示符，内存地址靠这个哦！
类型 type来看一看。
值 数据项。
某书里的傲娇结论：python里一切都是指针，所以不用再考虑指针这个问题了！
3。常用基本数据类型.
int 整型
boolean 布尔
string 字符串
list 列表
tuple 元祖
dict 字典4.数据类型的可变和不可变
不可变类型：int，string,tuple
可变类型:list,dict5.变量之赋值一切皆为引用，动态性与动态类型之为何不再动态
正确使用help()的不同：
>>> help(format)
Help on built-in function format in module builtins:
format(value, format_spec='', /)
Return value.__format__(format_spec)
format_spec defaults to the empty string
>>> help(str.format)
Help on method_descriptor:
format(...)
S.format(*args, **kwargs) -> str
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').lesson-09 列表
1 切片：
a = [1,2,3，4，5，6，7］正向索引
反向索引
a[-1:-4:-1]=[7,6,5] /反向索引时注意方向
>>> a[-1:-4:-1]
[7, 6, 5]
>>> a[-5:-1:1]
[3, 4, 5, 6]2添加操作：
- 生成一个新的列表
Extend 接受参数并将该参数的每个元素都添加到原有的列表中，原地修改列表而不是新建列表
id(a)
a.extend(b)
id(a)Append :添加任意对象到列表的末端
Insert: 插入任意对象到列表中，可以控制插入位置。3 修改：
修改列表本身只需要直接赋值操作就行。
A = [1,2,3]
A[0]=’haha’4 删除操作：
Del ：我们通过索引删除指定位置的元素。
Remove：移除列表中指定值的第一个匹配值。如果没找到的话，会抛异常。
Pop：返回最后一个元素，并从list中删除它。
5 成员关系：
In， not in我们可以判断一个元素是否在列表里。
返回一个bool类型，元素在列表里返回true，否则返回fasle.
6 列表推导式：
[expr for iter_var in iterable]1首先迭代iterable里所有内容，每一次迭代，都把iterable里相应内容放到iter_var中，再在表达式中应用该iter_var的内容，最后用表达式的计算值生成一个列表。
比如我们要生成一个包含1到10的列表
[x for x in range(1,11)]
Range(1,11)
[expr for iter_var in iterable if cond_expr]2加入了判断语句，只有满足条件的内容才把iterable里相应内容放到iter_var中，再在表达式中应用该iter_var的内容，最后用表达式的计算值生成一个列表。
要生成包含1到10的所有奇数列表。
range(1,11,2)
[x for x in range(1,11) if x % 2 == 1]7 排序翻转：sort,reverse
a = [33,11,22,44]
这个方式直接修改原列表。他的返回值为none，所以
b = a.sort()
print b 输出的内容是None
我们直接输出a列表变量
list的reverse函数：反转一个list, 他的返回值为none
比如上面的列表a
b = a. reverse()
print b 输出的内容是None
直接看a列表变量能看到翻转的效果。
1.内置list方法
a=”asd”
list(a)
返回一个列表，参数是可迭代对象，里面输出的内容还是保持了传入的可迭代对象的元素顺序。
如果参数为空，则返回一个空列表。
2.小技巧之删除
del a 删除列表对象的引用
del a[:]清空列表对象里的元素
lesson-11 元素和集合
一 元组：
特点：
1 有序的集合
2 通过偏移来取数据
3 属于不可变的对象，不能在原地修改内容，没有排序，修改等操作。
tuple类型转换
那为什么有列表还要有元组呢
元组不可变的好处。保证数据的安全，比如我们传给一个不熟悉的方法或者数据接口，
确保方法或者接口不会改变我们的数据从而导致程序问题。
def info(a):
'''一个我们不熟悉的方法'''
a[0] = 'haha'
a = [1,2,3]
info(a)
print a二 集合：集合是没有顺序的概念。所以不能用切片和索引操作。
1 创建集合。set():可变的 不可变的frozenset()：
2 添加操作： add，update
3 删除 remove
4 成员关系 in,not in
6 交集，并集，差集 & | -
7 set去重 列表内容元素重复encoding=utf-8
可变集合
info = set('abc')
info.add('python')##添加单个对象到集合里
print info
info.update('python')##把对象里的每个元素添加到集合里
print info
info.remove('python')
print info不可变集合
t = frozenset('haha')##不能进行添加，修改和删除的操作。
成员操作 in,not in
print 'a' in info
print 'h' in t
print 'jay' not in info判断2个集合是否相等，之和元素本身有关，和顺序无关。
print set(‘abc’) == set(‘cba’)
并集,交集，差集
print set('abc') | set('cbdef')##并集
print set('abc') & set('cbdef')##交集
print set('abc') - set('cbdef')##差集
所以可以用set的特性给list去重，先用set(a)将列表a转为set去重，然后在将set集合转为list(set)
liststr = ['haha','gag','hehe','haha']for循环
m = []
for i in liststr:
if i not in m:
m.append(i)
print m
m = set(liststr)
print list(m)lesson-12 字典
字典：
字典是无序的，它不能通过偏移来存取，只能通过键来存取。
字典 = {‘key’:value} key：类似我们现实的钥匙，而value则是锁。一个钥匙开一个锁
特点：
内部没有顺序，通过键来读取内容，可嵌套，方便我们组织多种数据结构，并且可以原地修改里面的内容，
属于可变类型。
组成字典的键必须是不可变的数据类型，比如，数字，字符串，元组等可以作为key，而列表等可变对象不能作为键.此处要注意元组的组成元素如果包含可变对象类型，也无法作为key会报错。
1 创建字典。{},dict()
info = {'name':'lilei', 'age': 20}
info = dict(name='lilei',age=20)
2 添加内容 a['xx'] = 'xx'
比如 info['phone'] = 'iphone5'
3 修改内容 a['xx'] = 'xx' ,
info['phone'] = 'htc'
update 参数是一个字典的类型，他会覆盖相同键的值
info.update({'city':'beijing','phone':'nokia'})
htc 变成了nokia了
4 删除 del,clear,pop
del info['phone'] 删除某个元素
del info 删除info变量对字典对象的引用
info.clear()删除字典的全部元素
info.pop('name') 传入key，返回对应的value，并且在dict中删除该key-value对
list.pop()与dict.pop()方法的区别，都是删除指定值并返回，
但如果dict.pop(index)的index不存在则直接抛出异常，
而dict.pop(key)不存在可以返回人为指定的值，而不抛异常
5 in 和 has_key() 成员关系操作
比如：
1 phone in info
2 info.has_key('phone')
6 keys(): 返回的是列表，里面包含了字典的所有键
values():返回的是列表，里面包含了字典的所有值
items：生成一个字典的容器：[()]
7 get：从字典中获得一个值
info.get('name')
info.get('age2','22') dict.get()与dict.pop()方法相似，
如果key不存在，则默认返回NoneType类型，
当然也可人为指定key不存在时返回某个值。lesson-15 再议数据结构与数据类型
1.list，dict，tuple之它们其实是好基友
1.1 没有最优秀的数据结构，只有最适用的
1.2 了解每个结构的特点才能活学活用
1.3 它们相互转换如此简单
2.“推倒式”（列表推导）与再议
[x for x in range(101]
第一部分 []
第二部分 x
第三部分 for x in range(101)
[x+1 for x in range(101] 列表生成器等同于如下
for x in range(101)
new_list.append(x+1)
print(new_list)3.排序
3.1 sorted与ob.sort()区别
3.2 list之sort方法
3.2.1 key最好用
3.2.2 cmp是什么(a>b) - (a<b)对a=[(‘a’,2),(‘b’,3),(‘c’,5)] 的数字部分进行排序
a.sort(key=lambda x:x[1],reverse=True)
4.字符串模板应用—字符串初始化的几种推荐方式
‘%s is a %s’ %(‘i’,’boy’)
‘this is {1} {0}’.format(“apple”,”my”) //在{}内指定位置顺序
‘{who} is a {gender}’.format(‘who’=’i’,’gender’=’boy’) //通过字典dict指定
‘{} is a {}’.format(‘i’,’boy’)4.1 回忆一下，字符串模板有哪几种方式
4.2 典型应用1：html模板
4.3 针对性比强大更为重要
lesson-18 习题练习
字符串大小写互换—a.swapcase()
判断是否数字——-a.isdigit()
总结字符出现次数—a.count(‘a’),技巧是先将原字符串转为set获取所有字符，这样就不需要判断原字符串的字符多样性。print(dict([x a.count(‘x’) for x in set(a)]))
case-1.4 请去除a字符串多次数显的字母，仅留最先出现的一个，例
'abcabb'，经过去重后，输出'abc'
a='jskldjsajjlasjefnsdf'
a_list=list(a) #转换为set去重，再转为list
set_list = list(set(a_list))
set_list.sort(key=a_list.index) #对去重以后的list进行排序
print(''.join(set_list))case-1.5 数字，大写，小写排序
a = 'aAsmr3idd4bgas7Dlsf9cAF'
l = sorted(a)
a_upper_list = []
a_lower_list = []
for x in l:
if x.isupper():
a_upper_list.append(x)
elif x.islower():
a_lower_list.append(x)
else:
pass
for y in a_upper_list:
y_lower=y.lower()
if y_lower in a_lower_list:
a_lower_list.insert(a_lower_list.index(y_lower),y)
print(''.join(a_lower_list))
case-1.9 输出a字符串中出现频率最高的字母
a = 'aAsmr3idd4bgas7Dlsf9cAF'
l=([(x,a.count('x') for x in set(a))])
l.sort(key=lambda k:k,reverse=True)
print(l[0][0])
case-1.8 在Python命令行里，输入import this以后出现的文档，统计该文档中，'be' ‘is’ 'than'的出现次数
import os
m = ls.popen('python -m this').read()
m= m.replace('\n','')
l = m.split(' ')
print([(x,l.count(x) for x in ['be', 'is','than'])])
case2.1清楚字符串中的数字,并排序
a = 'aAsmr3idd4bgas7Dlsf9cAF'
a=''.join([x for x in a if not a.isdigit()])
print(a)
print(sorted(a,reverse=True))lesson-20 函数基础课程
1.函数是抽象的第一步
1.1有关高压锅
1.2函数时抽象出来的结构，是总结，是方法
1.3多用函数
2.如何定义函数
2.1 def是关键词，括号冒号永不忘，无缩进无真相
2.2 没有return的函数，不是大丈夫–不是真函数
2.3 不写doc的函数，就像没有性别的人类
3.5 *和，猩猩是字典，星是元组
case1
def testDict(**a):
return a
print(testDict(a=1,b=2,c=3,d=4))
------output------
>>> print(testDict(a=1,b=2,c=3,d=4))
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>>
以key=value的形式作为参数输入，猩猩函数会自动将其识别为key-value键值对，当然必然要求key是唯一的，否则会报错。
>>> print(testDict(c=1,b=2,c=3,d=4))
SyntaxError: keyword argument repeated
>>>
case2:猩*是元组
def test2(*z):
return z
>>> print(test2(1,2,3,4,5,[1,2,3,5]))
(1, 2, 3, 4, 5, [1, 2, 3, 5])
>>>
case3 两者的结合体
def test3(*z,**a):
return z,a
print(test3(1,2,3,4,5,[1,2,3,5],a=1,b=2,c=3,d=4))
*****output******
>>> print(test3(1,2,3,4,5,[1,2,3,5],a=1,b=2,c=3,d=4))
((1, 2, 3, 4, 5, [1, 2, 3, 5]), {'a': 1, 'b': 2, 'c': 3, 'd': 4})
>>>注意这种情况，，与*参数顺序有先后要求。
