【学习笔记】老王Python-基础篇 python 2.x 【推荐指数2星】

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,dict

5.变量之赋值一切皆为引用，动态性与动态类型之为何不再动态

正确使用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})
>>> 

注意这种情况，，与*参数顺序有先后要求。