python基础知识点

2018/03/06 15:38
阅读数 12
 

一. 脚本格式,编程风格及数据基本介绍

 

一. python 脚本格式

前2行格式如下,第一行是表示用python执行,第二行是通用字符集,任何语言都能正常显示。
1)#!/usr/bin/env python
2)#_*_coding:utf-8_*_ (貌似写成#coding=utf-8也行)
 
其实上面的语句怎么写都行,只要符合coding[ := ]\s*([-\w.]+); 意思就是coding后面要紧紧的跟着冒号或者等号,之后可随意多少个空格,然后接utf-8,coding=utf-8前后随意加字符都行。
\w匹配的是能组成单词的字符
\s表示空格
 
3)第三行最好用双引号来写一个脚本文档,来对此脚本做解释
"......."
 
4)多行注释,三个双引号开头,三个双引号结尾。
"""
......
......
 
"""
注意,第一行很多人会写成#!/usr/bin/python,如果是系统默认有的python这样写是没错的,但是如果你升级了一个python,那么这个新版的python可能就会安装在usr/local/bin目录下,如果加上env,就会直接使用 新版的python,因为新装的python会自动写在env中。
 
 
2017/8/11 15:03

二. 编程风格

 
1. 语法要求,缩进统一: 属于同一代码块,也就是同一级别,相互之间没有依存关系的语言缩进必须是一致的,不然就会报错
 
注意,如果是在window下用notepad写的代码,用tab进行缩进时,需要在notepad中进行tab建和空格键的转换设置,在首选项中可设置。
 
2. 变量由字母,下划线,数字组成
标识符的 第一个字符必须是 字母(大小写都行)或者一个 下划线
标识符的其他部分可以由字符(大小写)*,下划线或数字(0-9)组成。
 
无效的标识符例子有 2things; this is a man; my-name
 
3.python编译过程--脚本解释型语言
在运行脚本之后,得到结果之前
1)python先将脚本编译成字节码(pyc,pyo)
脚本中只要import 函数,就会生成pyc文件
2)python虚拟机解释并运行字节码文件
 
C语言--编译型语言的内部机制
1)先将源代码编译成机器码,生成可执行文件
2)运行可执行文件
 
4,动态语义--在赋值时确定数据类型
例如 a=5 b=string, 那么用type(a)=int; type(b)=string
 
5. python之禅
进入python,输入import this 会看到
 
 
 
2017/8/14/周一 
 

三. python一切数据皆为对象

包含了一系列的数据和操作这些数据的方法的一个整体,就叫作对象。
 
一切变量都是对数据对象的引用
 
1. python内部的引用计数,sys.getrefcount
import sys
a='hello'
sys.getrefcount('hello')
输出为3---python中初始数为3
e='hello'
sys.getrefcount('hello')
输出为4
a=1
sys.getrefcount('hello')
输出为3,说明引用被销毁一次。
 
 
2.数据类型的组成
组成分为3部分。 
身份: id方法来看一看他的唯一标示符,内存地址靠这个哦!
类型 :type来看一看。
值: 表示数据项。
 
某书里的傲娇结论:python里一切都是指针,所以不用再考虑指针这个问题了!
 
 
3. 常用基本数据类型.
int 整型
boolean 布尔
a=True
b=False
注意:布尔值首字符必须大写
string  字符串
list 列表
tuple 元祖
dict 字典
 
 
4.数据类型的可变和不可变,意思就是如果变量的值改变后,id值是否改变
 
不可变类型:int,string,tuple
例如a = 5,看一下id值;然后a = 6, 再看一下id值,2个值是不同的
 
可变类型: list,dict
例如a = [1,2,3]
a.append(4),此时a=[1,2,3,4];但是改变前后,a的id值是不变的
 
 
5.如果给一个变量赋值后,它的数据类型就确定了,不能再随意改变
比如a="4",此时不能在进行a+1的运算,因为"4"和1不是一个数据类型,不能计算。如果想计算,需要先把字符串a转变为整型,方法就是int(a)+1.
 
 
 
 
 

二. 字符串认知与应用

 
 
认知1.字符串概念
 
认知2.ascii unicode utf8到底是啥
 
 
一 . len()
len:全写是length,是计算容量的函数;例如a = "1234", len(a)=4
如果是中文字符,比如a = "哈", len(a)=3, 那么怎么显示正确的数目呢? (在python3中不存在这个问题)
 
方法一:
在中文字符前加u    例如:a = u"哈" ,len(a)值为1
 
方法二:
a ="哈哈"
g = a.decode('utf-8')
print len(g)值为2
也可以直接写成 a = "哈哈".decode('utf-8'), 其实最好是a.decode('utf-8')
 
注意:
就是在脚本中标明#coding=utf-8,len的值还是按ascii码来计算
比如
#coding=utf-8
d = "中文"
print len(d)
执行python test.py的值为6
 
 
二.转义符让文本更好处理
要转义的字符前面加个反斜杠
 
 
三. 字符串前面跟着的小尾巴到底是什么东西
例如: print r"\n"     其中的字母 r 表示不对 斜线 进行转义,输出为 \n
 
 
四. 访问子字符串
 
成员有是有序排列的,可以通过下标偏移量访问到它的一个或者多个成员
a = "abcd"
print a[0]  第一个字符
print a[-1] 最后一个字符,也可以是print a[len(a)-1]
a[0: ] 输出为abcd
a[0:1] 输出为a
a[0:2] 输出为ab
a[1:3] 输出为bc 注意第一项不是0,那么 输出项是从a[1]开始的3-1位,并不会输出a[3]
a[:-1] 输出为abc
 
 
五. 替换字符串--replace()方法
a = "abc"
a.replace('a','hh')
'hhbc'
但是此时print a,输出还是abc,说明 replace()并不会改变原变量值,如果想修改原值,可以重新赋值,比如
a = a.replace("a","his"),输出为hisbc
 
 
六.查找字符串--find()方法
a.find("hong") 如果找到了字符串"hong"会返回一个整型,这个数值是a字符串对象hong第一个字母"h"的下标  ,如果找不到"hong",会返回-1
如果有多个hong,怎么指定某一个hong呢,例如
a = "hong my name is hong"
此时用a.find("hong") 输出结果会是0,就是从第0个字符开始的就是hong,怎么找后面的那个hong呢?
a.find("is") 输出为13
a.find("hong",13)就会输出is后面的hong了,注意用help(a.find)文档
 
 
 
七. 字符串拼接
 
1.直接用加号来拼接,太耗资源,超级丑陋之千万别用。
 
2.可选方案之字符串模板
用%s....%来拼接: %s表示要插入字符串,叫做占位符;%后面的字符表示要插入字符串的内容
占位符通常有2种,%s:字符串的占位符, %d:数字的占位符。
 
例如
1)  print "my name is hong, %s"  %  "i am 18"
2)  print "my name is %s %s"  % ("hong", "ten years old")
3)  print "my name is hong, i am %d"  % 18
4)print "this is a %s %s"  % (4,10),输出为this is a 4 10. 也就是说可以强制把整型转为字符串,小括号里的数据要按顺序写
 
 
3.优秀的拼接方案之使用join(),这种方法在参数是变量的情况比较好用
>>> a = "a"
>>> b = "bcd"
>>> c = "12cd"
>>> "".join([a,b,c]) 
'abcd12cd'
 
用 [] 把abc变成一个list,才能用join()进行拼接直接用join(a,b,c)报错,因为join()函数只能有一个参数
 
注意:
join()函数基本语法: 'sep'.join(seq),表示以sep为分隔符,将seq所有的元素合并成一个新的 字符串
sep表示分隔符,可以为空;
seq表示要连接的元素序列,字符串,元组或者字典,也就是说上面的"".join([a,b,c])也可以把参数写成元组 "".join((a,b,c))
 
 
4. format格式化方式
b = "this is {} {}" .format ("my","apple")为什么要用format
print b
输出为 this is my apple
 
如果想调整一下输出参数的顺序,那么可以这样写
b = "this is {1} {0} .format ("my","apple"),那么输出结果就是
this is apple my
需要注意的是参数从0开始
 
算参数位置太麻烦,有时候还出错,来种更人性化的方法
b = "this is {whose} {fruit}" .format (fruit="apple",whose="my")
print b
输出为this is my apple
 
 
5. 还有一个方法,字典来了。
a = "this is %(whose)s  %(fruit)s"  % {'whose':'my','fruit':'apple'}
其中whose:my, whose是key位,my是word位
 
 
 
七. 读写文本
 
1. 在指定的文件中写入内容
d = open('a.txt','w')
d.write('hi,\nhello')
d.close()
 
说明:open()中的第二个参数含义
w :write
r :read
a :append
 
 
2. 读取指定文本内容
d = open('a.txt','r')
help(d)  #查看对象d可使用的方法属性,举例说明readline(), readlines()以及read()的使用方法和区别
 
1)  readline(),每次读取单行文本内容
print d.readline()    
hi
print d.readline()
hello
 
2) read(),一次读取所有内容,以文本形式显示

>>> print d.read()
hi,
hello

注意:print d.read(100),但是显示为空,需要用d.seek(0)来调整一下读取位置,然后再print d.read(100)就能看到全部信息量,100不够就1000

 
3) readlines(),也是一次读取所有内容,不过是以列表的形式显示

>>> print d.readlines()
['hi,\n', 'hello']

可用for循环显示每行内容

for line in d.readlines():
    print line
 
小结:
.readline() 和 .readlines() 之间的差异是后者一次读取整个文件,象 .read() 一样。
.readlines() 自动将文件内容分析成一个行的列表,该列表可以由 Python 的 for … in … 结构进行处理。
另一方面,.readline() 每次只读取一行,通常比 .readlines() 慢得多。仅当没有足够内存可以一次读取整个文件时,才应该使用 .readline()。
 
 
4) 使用标准库 linecache,也可实现访问指定文本行
 
a = open("tmp.txt","w")
a.write("haha\n12faf\nhong")
a.close()
 
如果想在python命令行中输出上面tmp文件的第一行,第二行内容,可以如下写。
import linecache
help(linecache)
print linecache.getline("tmp.txt",1)
print linecache.getline("tmp.txt",2)
 
使用这种方法的好处是不要考虑重置指针(seek函数)的问题,可随意取任意行
 
2017/8/15 8:59
 
 
 
 
八. 三个符号的区别 :一对单引号,一对双引号,一对三个双引号
 
python中单双引号没区别,单引号里可以写双引号,双引号里也可以写单引号
一对三个双引号作用是格式化的输出多行内容,而且里面的内容可以任意加单引号,双引号等。例如
print """
    author
    "date"
    'money'
"""
和多行注释用法一样
 
 
 
 
 
 
 

三. 列表

 

一. 列表基本特点

1.  有序的集合
a = [1,2,3]
 
2 通过偏移来索引,从而读取数据
a[-1]输出为3
 
3 支持嵌套
b = [[1,2,3],[4,5,6]]
b的输出为[[1,2,3],[4,5,6]]
此时如果想修改2为7,方法是b[0][1] = 7
 
4. 可变的类型
 
 
 
 
 

二. 列表基本使用方法

1. 切片:
a = [1,2,3,4,5,6,7]
 
正向索引
a[0:4:1] 表示从0位开始去到第4位,步长为1,结果为[1,2,3,4]
 
反向索引
a[-1:-4:-1],取到[7,6,5] # 反向索引的步长一定要加上,并且步长要写为负数
 
默认索引
a[1:], 取到[2,3,4,5,6,7]
a[1::2], 取到[2,4,6]
 
注意:不管是正向索引还是反向索引,索引后面的一个值,是不算在内的
 
 
2.  添加操作:
 
1) + 生成一个新的列表
a = [1,2,3]
b = [4,5,6]
a + b 输出为[1,2,3,4,5,6]
 
2) Extend,扩展list,参数为其他列表名,结果是新元素自动融入list,类型一样。
接受参数并将该参数的每个元素都添加到原有的列表中, 原地修改列表而不是新建列表
a.extend(b)
a的输出为[1,2,3,4,5,6], 对比操作前后的id(a),值是不变的
 
3) Append :添加任意对象到列表的末端,参数为单个元素,这个元素可以是数字,也可以是list或者元组本身。
加入数字
a = [1,2,3]
a.append(4)
a的输出为[1,2,3,4]
加入列表
a.append([3,4,5])
a的输出为[1,2,3,4,[3,4,5]]
 
4) Insert: 插入任意对象到列表中,可以控制插入位置
a.insert(1,"ab") 表示 在下标为1处加上元素“ab”
a的输出结果是[1,"ab",2,3,4,[3,4,5]]
 
 
 
3. 修改:
修改列表本身只需要直接赋值操作就行。
 
A = [1,2,3]
A[0]=’haha’
 
 
 
4. 删除操作:
 
1) Del :我们通过 索引删除指定位置的元素。
a = [1,2,3,4,5]
del a[0] #只有del是用命令del,其他都是通过 a.函数名 的方式调用实现相应功能。
a输出为[2,3,4,5]
 
2) Remove:移除列表中指定值的 第一个匹配值。如果没找到的话,会抛异常。
a.remove(4) 
a.remove(6)
这里的参数4,6都是具体的列表中的实际值,而不是下标 
 
3) Pop:返回最后一个元素,并从list中删除它。
a.pop(),输出为5,并删除5
也可指定元素索引值,弹出并删除指定元素,比如a.pop(1),弹出并删除数字2
 
 
 
5. 成员关系:
通过in, not in的方法,我们可以判断一个元素是否在列表里。返回一个bool类型,元素在列表里返回true,否则返回fasle.
 
a = [1,2,3]
2 in a
True
5 in a
False
 
5 not in a
True
 
 
6. 列表推导式:
 
一般的,[expr for iter_var in iterable]
 
首先迭代iterable里所有内容,每一次迭代,都把iterable里相应内容放到iter_var中,再在expr中应用该iter_var的内容,最后用expr的计算值生成一个列表,。
 
比如我们要生成一个包含1到10的列表
方法一
[x for x in range(1,11)]
输出为[1,2,3,4,5,6,7,8,9,10]
 
方法二
range(1,11)    #python2中,这种方法可以输出1-10的列表,但是在python3只会输出一个range类型range(1,11)
 
 
有条件的,[expr for iter_var in iterable if cond_expr]
 
加入了判断语句,只有满足条件的内容才把iterable里相应内容放到iter_var中,再在表达式中应用该iter_var的内容,最后用表达式的计算值生成一个列表。
 
要生成包含1到10的所有奇数列表。
 
方法一
range(1,11,2)  同理python2中可生成奇数列表,python3中不行
 
方法二
[x for x in range(1,11) if x % 2 == 1]
 
注意:表达式中的x都是表示一个相同的东西,我能改的只能是表达式的形式,也就是第一个x,比如改成x+1.
 
 
 
 
7.  排序和翻转:sort,reverse
 
sort:这个方式会直接修改原列表,它的返回值为none,所以b = a.sort()  ,print b 输出的内容是None
例如
a = [33,11,22,44]
b = a.sort()
b的输出结果为None,也就是什么都不输出,可以用if语句判断
if b is None:
    print "haha"
此时再输出a,发现a已经按顺序排好,输出为[11,22,33,44]
 
reverse和sort同理
b = a.reverse() #b的输出也是None
再看a的输出,发现a的值已经反转了
[44,33,22,11]
 
 
 
 
 
 
 
2017/8/16 
三. 列表常见应用
 
 
1. 内置list的方法,常用来把字符串或者元组改成列表类型
 
a = "asd"
list(a)
['a','s','d']
返回一个列表,参数是可迭代对象。里面输出的内容保持了传入的可迭代对象的元素和顺序
 
元组转为列表
list((1,2))
输出为[1,2]
 
但是如果传入数字,就会报错,因为数字是不可迭代的对象
list(10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
 
 
 
2.xrange和range的区别(只在python2中使用起来有区别)
 
xrange(开始,结束,步长)步长省略的话,默认为1
 
2个函数的区别:
xrange 会生成一个xrange对象,
range直接生成一个列表对象
 
创建一个xrange对象
>>> a = xrange(1,10)
>>> a
xrange(1, 10)
>>> a[0]
1
>>> a[3]
4
 
创建一个range对象b 
>>> b = range(1,10)
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b[0]
1
>>> b[3]
4
 
xrange的使用场合
1. 当我们需要操作一个非常大的数据,而且内存比较吃紧的时候,我们可以用xrange来操作省内存
2. xrange一般用在循环里面,比如我们只需要操作部分数据,而不是返回全部元素来完成操作,推荐使用xrange
 
比如
for m in range(1000):    #range()生成一个包含[0-999]的对象
 
    if m == 10:
    print "sss"
    break
 
for m in xrange(1000): # xrange()每一个迭代循环,只返回一个元素,只需返回[0-10],11个对象
    if m == 10:
    print "sss"
    break
 
 
 
 
3. 列表推导式之再应用
 
复习例子1,取出1-100的所有值的平方
按从右向左的顺序来写,比较人性化,先写一个1-100的序列,让x迭代,然后左边写运算,最后加一个中括号
[x*x for x in range(100)]
 
常见应用如下
 
1)生成字符串
["the %s" % x for x in xrange(10)]
输出为 ["the 0","the 1","the 2","the 3",...."the 9"]
 
2)生成元组
for x in range(2)  先生成一个列表,进行迭代
for y in range(2)  再生成一个列表,进行迭代
定义一个元组(x,y)
定义列表,也就是加上中括号
完整的句子就是:
[(x,y) for x in range(2) for y in range(2)]
输出如下
[(0,0),(0,1),(1,0),(1,1)]
 
3)生成字典,就是上面的一个打包操作,加上dict()
dict ([(x,y) for x in range(2) for y in range(2)])
输出如下
{0:1,1:1}
冒号左为key,右为value。 key如果相同,后面的key会覆盖前面的key,所以前面的2个值(0,0),(0,1)只会有0:1; 后面的2个值也只会有1:1,道理一样。
 
 
 
 
4. 小技巧之再议删除
 
1)删除列表对象的引用
 
>>> a = [1,2,3]
>>> b = a  # 此时查看列表对象的地址,用id()查看,发现a,b的id值是一样的,也就是引用的列表对象的存储位置是一样的。
>>> del a
>>> b
[1, 2, 3]
 
 
2)清空列表对象里的元素
>>> c = b
>>> del c[:]
>>> c
[]
>>> b
[]
 
 
说明:
赋值符号“=”,表示引用,表示传址调用,他们有相同的ID号,如果修改某一个变量,另一个变量也会相应修改
[:] 表示复制,传值调用,2个变量ID号不同,此时修改b,不会影响a的值
 
a = [1,2,3]
b = a[:] #这个[:]是个什么东西
del a
b的值是什么。为什么呢?
 
当b=a时
>>> a=[1,2,3]
>>> b=a
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
 
>>> id(a)
140076707413024
>>> id(b)
140076707413024
 
当b=a[:]时,这里生成了一个新的列表对象,b的变化,不会影响下面a的输出。
>>> a=[1,2,3]
>>> b=a[:]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
 
>>> id(a)
140076707334048
>>> id(b)
140076707335272
 
>>> b=[1,2,3,4]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3, 4]
 
 
 
 
 
 
 
 
2017/8/17 8:52

四. 元组和集合

 
1. 元组是有序的集合
a = (1,2,3)
 
2. 通过偏移来取数据,也是通过下标来取,和列表一样。区别就是list是可变的,元组是不可变的。
a[0] 输出为1
a[1:3] 输出为(2,3)
 
3. 属于不可变的对象,不能在原地修改内容,没有排序,修改等操作。
dir(a)可以看到所有支持的方法
要想修改元组,需要先把元组重新赋值给一个列表,然后修改列表元素,之后再把列表转变给元组。方法如下
b = list(a)
b[0] = 5
type(b) 输出为list
a = tuple(b) #生成了一个新的元组对象
a
输出为(5,2,3)
 
 
tuple类型转换
 
那为什么有列表还要有元组呢?
元组不可变的好处。保证数据的安全,比如我们传给一个不熟悉的方法或者数据接口,确保方法或者接口不会改变我们的数据从而导致程序问题。
 
例子1
#encoding=utf-8
def info(a):
    print "id %d" % id(a)
    #a[0] = "haha"  第一个脚本完成后加这行进行测试
    #return a 这行也是测试的
a = [1,2,3]
print "start-"
print id(a)
info(a)
#print a  测试用的
 
 
另外一种方法
#encoding=utf-8
def info(a):
    b = a[:]  #这里生成了一个新的列表对象,b的变化,不会影响下面a的输出。
    b[0] = "haha"
    return a
a = [1,2,3]
print "start-"
print id(a)
info(a)
print a
 
 
 
二. 集合
 
集合是没有顺序的概念。所以不能用切片和索引操作。
 
1. 创建集合
 
set():可变的
a = set("abc")
a
输出为set(['a', 'c', 'b'])
 
不可变的frozenset():
>>> a = frozenset("abc")
>>> a
frozenset(['a', 'c', 'b'])
 
>>> a.add("222")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
 
>>> a.remove("a")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'remove'
 
查看对象是否可迭代的方法
用dir进行查看,比如dir(a),如果输出中有"_iter_",说明可以进行迭代。
 
 
2. 添加操作: add,update
add函数
a.add("python")
a
输出为
set(['a', 'python', 'c', 'b'])  #"python"做为一个整体来加入。
 
update函数
>>> b = set("hong")
>>> b
set(['h', 'g', 'o', 'n'])
>>> b.update("python")
>>> b
set(['g', 'h', 'o', 'n', 'p', 't', 'y']) #python分开来插入,如果重复自动忽略
 
注意:
update的参数也可以是list,如果使用list,那么集合中新加的元素还会保持原先list中的顺序。
比如c='hong' 
      b.update(list(c))
 
 
3. 删除 remove
a.remove("python")
a
输出为
set(['a', 'c', 'b'])
 
4. 成员关系 in,not in
"c" in a
True
"h" not in a
True
 
5. 交集,并集,差集 & | -
a = set('abcd')
b = set('bcdef')
 
a & b
set(['c','b','d'])
 
a | b #并集
set(['a','c','b','e','d','f'])
 
a - b #差集
set(['a'])
 
6. set去重  
例子
>>> a = [1,2,3]
>>> a.append(1)
>>> a.append(3)
>>> a
[1, 2, 3, 1, 3]
>>> set(a)
set([1, 2, 3])
>>> list(set(a))
[1, 2, 3]
 
 
 
 
 
基础篇12-字典
 
 
字典是无序的,它不能通过偏移来存取,只能通过键来存取。
例1
 
>>> info = {'a':1,'b':2}
>>> info
{'a': 1, 'b': 2}
 
可以通过键值返回value值
>>> info['a']
1
 
例2
>>> binfo = {'a':[1,2,3],'b':[4,5,6]}
>>> binfo
{'a': [1, 2, 3], 'b': [4, 5, 6]}
 
>>> binfo['a'][2] = 5
>>> binfo
{'a': [1, 2, 5], 'b': [4, 5, 6]}  #说明字典是可变的类型。
字典 = {'key':value} key:类似我们现实的钥匙,而value则是锁。一个钥匙开一个锁
 
 
特点:
内部没有顺序,通过键来读取内容,
可嵌套,方便我们组织多种数据结构,并且可以原地修改里面的内容,属于可变类型。
 
组成字典的键必须是不可变的数据类型,比如,数字,字符串,元组等,列表等可变对象不能作为键.
 
例3
key 为数字
>>> binfo = {1:"22",2:"dd"}
>>> binfo
{1: '22', 2: 'dd'}
 
key为字符串
>>> cinfo = {"a":"222","b":111}
>>> cinfo
{'a': '222', 'b': 111}
 
key为元组,需要注意的是元组中的元素也必须是不可变类型。
>>> dinfo = {(1,2,3):'ss',('b','c'):'222'}
>>> dinfo
{('b', 'c'): '222', (1, 2, 3): 'ss'}
 
元组中的元素是列表
>>> xinfo = {(1,'2',[2,3]):'a'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
 
key为列表
>>> finfo = {[1,2,3]:'sss'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'   
 
 
1. 创建字典。{},dict()
 
法1
info = {'name':'lilei', 'age': 20}---------------一般情况下还是用法一好!
 
法2
info  = dict(name='lilei',age=20)
name是key,'lilei'是value
 
注意:
1. 法一是用花括号,法二是用小括号;
2. 法一key和value中的字符串必须加引号;法二key的字符串可以不用加双引号,value的字符串必须加双引号。
3. 法一用冒号,法二用等号
 
 
2. 添加内容 a['xx'] = 'xx'
 
比如在法1例子的基础上加上如下命令
info['phone'] = 'iphone5',其中phone为key, iphone5为value
>>> info ={'name':'lilei','age':20}
>>> info
{'age': 20, 'name': 'lilei'}
 
>>> info['phone'] = 'iphone5'
>>> info
{'phone': 'iphone5', 'age': 20, 'name': 'lilei'}
 
 
3. 修改内容 a['xx'] = 'xx' 
 
info['phone'] = 'htc'
 
update 参数是一个字典的类型,他会覆盖相同键的值
 
在例2的基础上做下面操作
>>> info.update({'city':'beijing','phone':'nokia'})
>>> info
{'phone': 'nokia', 'age': 20, 'name': 'lilei', 'city': 'beijing'}
 
 
4. 删除 del,clear,pop
 
1)del ainfo['phone'] 删除某个元素
 
>>> ainfo = {'age':22,'aa':22}
>>> ainfo
{'aa': 22, 'age': 22}
>>> del ainfo['aa'] #删除'aa'元素
>>> ainfo
{'age': 22}
 
删除ainfo的引用
>>> del ainfo
>>> ainfo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'ainfo' is not defined
 
 
2)clear()删除字典的全部元素
>>> a = {'info':'22','age':'34'}
>>> a
{'info': '22', 'age': '34'}
>>> a.clear()
>>> a
{}
 
3)pop('name')
字典的pop方法
>>> a = {'11':'aa','bb':22}
>>> a
{'11': 'aa', 'bb': 22}
>>> a.pop('bb') #传入需要删除目标的key,就可删除。
22
>>> a
{'11': 'aa'}
 
需要注意的是,如果pop的key不存在,我们可以指定一个输出值让系统显示出来,
以上面字典a为例
>>> a.pop('33')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: '33'
>>> a.pop('33','not exist')
'not exist'
 
列表的pop方法
>>> binfo = []
>>> binfo.append('22')
>>> binfo.append('234')
>>> binfo
['22', '234']
>>> binfo.pop(0) #传的是索引下标
'22'
>>> binfo
['234']
 
 
5. in 和 has_key() 成员关系操作
 
例如
>>> a
{'11': 'aa', 'bb': 22}
 
1).in
>>> "phone" in a
False
 
2) a.has_key()
>>> a.has_key('11')
True
>>> a.has_key('aa')
False
 
3). keys(): 返回的是列表,里面包含了字典的所有键
>>> a.keys()
['11', 'bb']
 
4). values():返回的是列表,里面包含了字典的所有值
>>> a.values()
['aa', 22]
 
5) items():生成一个字典的容器:------这个方法是字典转变为list的途径
>>> a.items()
[('11', 'aa'), ('bb', 22)].里面的每一项都是一个元组,元组第一项为key,第
二项为value
 
6) get:从字典中获得一个值
>>> a.get('11') #参数为key,输出为value
'aa'
>>> a.get('33') #key不存在,输出为空,且为NoneType类型
>>> b = a.get('33')
>>> type(b)
<type 'NoneType'>
 
>>> a.get('33','not exist') #key不存在,可以指定默认输出值
'not exist'
 
 
 
 
基础篇13-答疑课
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)]    ##这里不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##这里不明白
 
一. 先得讲讲二进制
0 + 1 + 1 9 +1  = 10
99 +1 = 100
2进制冯二进1
0 +1 = 1
1 +1 = 10
10 +1 = 11
11 +1 =  100
100 + 1 = 101
101 + 1 = 110
 
 
二. 难缠符号来啦
bin:把10进制转换为2进制
例子
>>> bin(3)
'0b11'
只看0b后面的数值,就是转换后的2进制
 
1.难缠符号之一 >> <<
位移,移动的是2进制的位
例子
>>> 5 >> 1
2
5的2进制是101,向右边移动一位,结果就是10,十进制结果就是2
>>> 3 << 1
6
3的二进制是11,左移一位变为110,十进制就是6
 
2.难缠符号之二 &
按位与,对应位都是1结果才是1,其他都是0
1100
1000
1000
例子
>>> 10 & 20
0
10的2进制:01010   #第一位的0是补的
20的2进制:10100
发现没有一个对应位是1的,所有结果是全0.
>>> 40 & 32
32
注意2进制转变为10进制
>>> int(0b100000)
32
 
3.难缠符号之三  |
按位或,对应位只需一个为1,结果就是1
0100000
1100100
1100100
例子
32 | 100
100
 
4.难缠符号之四  ^
按位异或,对位相加,不进位
101
011
110
 
5.难缠符号之五 ~
按位取反,2进制数加1后,乘以-1
例如~5 = -6
~5=-(101+1)=-110=-6
所以
3+~5=-3
注意不能直接写3~5,这样是错的
 
三. 其他
 
1.&之奇偶判定,和1进行按位与运算,结果为1就是奇数,结果为0则是偶数
 
5 & 1
1
4 & 1
0
 
2.计算硬盘容量
比如一个文件大小是11866字节,想知道有多少k,那就是向右移10位,相当于11866除以2的10次方,相应的,想知道有多少M,就向右边移动20位。
11866 >> 10
 
3.真真假假不知晓
False & True & True
False
True & True & True
True
if is_boy() & is_18() & is_chinese():
    print
 
四.回过头来再看这道题
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)]    ##这里不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##这里不明白
 
 
 
2017/8/18 9:57
基础篇15. 答疑课之二:再议数据结构与数据类型
 
1.list,dict,tuple之它们其实是好基友
    1.1 没有最优秀的数据结构,只有最适用的
    1.2 了解每个结构的特点才能活学活用
    1.3 它们相互转换如此简单
list是有序的
dict是无序的,适合存储有复杂名称的数据,比如{"xiaoming":86},比如电话薄,班级成绩单。
a = (1,2,3,4)
a = list(a) #元组转换成list
然后把list转变成tuple
a = tuple(a)
list转换成字典
a = [(1,3),(2,4)]
a = dict(a)
 
2.“推倒式”(列表推导)与再议
[x for x in xrange[101]
第一部分 []
第二部分 x
第三部分 for x in xrange[101]
等价于
new_list = []
for x in xrange(101):
    new_list.append(x) #这里的x等同于第二部分的x
print new_list
 
3.排序
 
3.1 sorted--------可以用在字符串中进行排序,会生成一个list
help('sorted')来看帮助文档
a = [1,2,3,4]
sorted(a,reverse=True)
[4,3,2,1]
a
[1,2,3,4] #说明sorted并不是原地修改
要想修改a的值,需要赋值
a = sorted(a,reverse=True) 
 
 
3.2 list之sort方法
a = [1,2,3,4]
a.sort(reverse=True)
a
[4,3,2,1] 说明内置函数sort是原地修改
 
sort帮助文档中的信息
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
    cmp(x, y) -> -1, 0, 1
 
key最好用,它可以对list中的元素进行操作
例1
>>> a = ["43214","324214","82310","9231"]
>>> a.sort(key=int)
>>> a
['9231', '43214', '82310', '324214']
>>> a.sort(key=int,reverse=True)
>>> a
['324214', '82310', '43214', '9231']
 
例子2,按照list中元组元素的第2个数字大小进行排序
>>> a = [('a',2),('b',5),('c',4)]
>>> a.sort(key=lambda x:x[1]) #x表示每一个元组单元,x[1]表示元组中下标为1的元素,也就是数字2,5,4.
>>> a
[('a', 2), ('c', 4), ('b', 5)]
>>> a.sort(key=lambda x:x[1],reverse=True)
>>> a
[('b', 5), ('c', 4), ('a', 2)]
 
cmp是什么
cmp是用来比较2个数字的值,只会返回三个结果:0,1,-1.    能用key最好不用cmp,python3中已经弃用,性能不好
用法
cmp(a,b) 等同于公式(a>b) - (a<b)
>>> cmp(1,3)
-1
>>> (1>3) - (1<3)
-1
>>> cmp (3,1)
1
>>> cmp (3,3)
0
            
    
3.3 多级排序咋个办
如下,按元组元素中的后两位数字进行排序,我的理解就是后两位看做一个数比大小。
>>> a = [(3,1,2),(6,7,8),(6,5,9)]
>>> import operator
>>> a.sort(key=operator.itemgetter(1,2)) #这里的1,2表示下标。
>>> a
[(3, 1, 2), (6, 5, 9), (6, 7, 8)]
 
3.4 字典如何去排序
自己摸索。。。
 
4.字符串模板应用
4.1 回忆一下,字符串模板有哪几种方式
"%s is a %s" %("he","boy")
"%(who)s is a %(gender)s" %{"who":"he","gender":"boy"}
"{who} is a {gender}".format(who="he",gender="boy") 这种最好
 
4.2 典型应用1:html模板
也是用占位符来替代相应模块中的内容
 
4.3 针对性比强大更为重要
三种字符串模板灵活运用,看哪个适用
 
 
 
 
基础篇16-python语句讲解1
 
1. print语句
    1.1 基本输出
    1.2 print的逗号
    1.2 输出到文件 >>为重定向
 
解释与例子
在python脚本中,如果写入
print "2"
print "3"
那么执行的时候会自动进行换行,输出为
2
3
 
如果脚本中加上逗号,如下
print "2",
print "3"
那么执行的时候输出就是
2 3
不会进行换行,所有逗号的意思就是print语句还没执行完。
 
输出重定向,使用print命令来写文件内容  -----以后我就用这个方法吧,命令行也行
脚本中如下写
f = open('print.txt','w')
#一般情况下写入文件应该用命令f.write("my name is hong"),这里用print来写
print >> f,"my name is hong"
print >> f,"i am from china"
f.close()
这里当然也可以用逗号,来使2行变一行。
 
2. 控制流语句(control flow)
    2.1 由条件和执行代码块组成。
        2.1.1 条件可分为决策、循环和分支
    2.2 格式(冒号与4个空格永不忘)
    2.3 if,while,for 函数,皆为contorl flow
 
解释和例子
if True:  #冒号分隔了条件和代码块。
    print 4 #4个空格缩进的代码块
x = 3
if x: #相当于 if x == if bool(x),返回结果为True
    print 4
 
3. 布尔值
    3.1 控制流与真假值息息相关
        3.1.1 不要误解了真假与布尔值
    3.2 布尔值的几个最基本运算符
        3.2.1 and 全部都为bool真
        3.2.2 or 至少一个为bool真
        3.2.3 is 检查共享
        3.2.4 == 检查值
        3.2.5 not
        3.2.6 其他若干比较符号
 
>>> True and False
False
>>> True or False
True
 
is是检查是否引用了同一个数据对象
>>> 5 is True
False
5是引用了一个整型的数据对象,True引用的是一个布尔类型的对象,所有结果是False
>>> a = 5
>>> b = 5
>>> a is b
True
 
== 检查左边和右边的值是否相同
1 == True
True
虽然左边是整型,右边是布尔型,但是他们的值都是1,所以返回True
>>> 4 == 9
False
 
not:取反。如果要表示真,后面一定要跟False,做这个的是太无聊了,整点花样。
if not False:
    print "not False"
 
   
4. if语句 (控制流语句)
    
    4.1 if的组成 if else elif pass
        4.1.1 if与elif替代了switch
        4.1.2 pass  
  
例子
if True:
    print "True"
else:
    print "False"
if True:
    print "True"
elif not True:
    print "not True"
else:
    pass #什么都不做
    
    4.2 奇技淫巧 三元表达式
        4.2.1 x if  else
        4.2.2 活用list  
        4.2.3 三元表达式玩玩就好
 
例子1
4 if True else 3
等同于
if True:
    print 4
else:
    print 3
>>> 4 if True else 3
4
 
例子2
>>> [4,3][True] #True值为1,所以返回下标为1的list值
3
>>> [4,3][False] #False值为0,所以返回下标为0的list值
4
>>> [4,3][0]
4
>>> [4,3][1]
3
 
 
 
 
基础篇17-python语句讲解-2
 
1.复习
    1.1 控制流的基本组成部分 条件,执行代码块。
    1.2 if的基本格式
        if expression:
            statement(s)
    1.2 控制流的条件表达式(expression)结果,必须为True(真),比如 条件可以写成if not True: 这样的返回结果为真,而不能写成if False,返回为假
    1.3 冒号永不忘。尽量使用4个空格,而不是制表符
        
            
2.while语句
    
2.1 while的基本格式
    while expression:
        statement(s)
例子1
x = 1
while True:
    x += 1
    print x
    #continue 通过加减这个命令来测试
    if x > 20:
        break
else:
 
2.2 while的基本组成部分
    2.2.1 break 结束while
    2.2.2 continue 跳出当前这次循环,但不结束while
    2.2.3 else 结束while以后执行,是正常跑完,不是通过break强行结束。也就是说不能和break连用,不然break会把else语句也掐断。但是可以和continue一起用
while x < 20:  #可以在while表达式中用<
    x += 1
    #continue  来测试是否能和continue一起用
    print x
else:
    print "end"
 
2.3 注意:普通应用里,while一定要给一个结束条件,否则就是传说中的死循环
 
3.for语句
 
3.1 for的基本格式
    for item in iterable:
        statement(s)
例子
for x in "hello,my name is hongjin"
    print x
 
消除空格
for x in "hello,my name is hongjin".split(" "):
    print x
 
用一行来显示出来文本内容
for x in "hello,my name is hongjin".split(" "):
    print x,
 
3.2 for的基本组成部分
    3.2.1 break
    3.2.2 continue
    3.2.3 else
 
3.3 注意:for的最后一个迭代值将保留,也就是循环结束后,最后一个循环取得值将被保留在内存中。如果不注意的话,可能会出现错误
 
 
4.布尔值再议
 
4.1 惰性求值,需要时再求值。
4.2 从左到右,从先到后。
4.3 利用小技巧。or之默认值。
 
比如
True and False and False and True
python在进行计算时,看到第二个是False,后面的就不计算了,直接返回False
在进行运算时,可以把可能是false的计算放在前面,把其他运算量很大的计算放后面,这样效率高
 
or之默认值
比如在爬网页的时候
定义一个变量
from_url = url.get("from") or None
就是爬上面的网址from后面的参数"=126mail",有时候from后面有内容,有时候没有,如果没有的话,脚本还想继续运行,就需要加上or None
 
 
 
 
 
基础篇18-语句与数据结构应用
 
1.最基本的迭代
a = "abcdefg"
for i in a:
    print i
b = [1,2,3,4,5]
for i in b:
    print i
 
2.如何迭代字典
a = {"key":"value","key1":"value1"}
print a
a = {"key":"value","key1":"value1","key1":"value2"}
print a
相同的key,只会输出最后一个key的value
for i in a.keys():
    print i
命令行中看一下a.items()是什么
脚本中
for x,y in a.items():
    print x,y
 
3.如何为字典排序
例子1,把下面字典元素按照key中的字母序列排序
a = {"a":"haha","b":"xs","d":"fa","c":"faff"}
key_list = a.keys()
key_list.sort()
#print key_list
for x in key_list:
    print x,a[x]
注意:字典可以使用如下方式查看字典的value
>>> print a["a"]
haha
 
4.字典根据键值查找键
那么如果想从字典的value得到key,应该怎么做呢
分析:
1) 字典索引的是键,而不是值 => 迭代,穷举
2) 字典具有唯一键,但值不要求唯一
3) 一个值可能对应多个键
 
例子,不同的key都有相同的value值,
a = {"a":"haha","b":"xixi","d":"haha","e":"xixixi","c":"haha"}
search_value = "haha"
key_list = []
for x,y in a.items(): #找到所有的key, value, for x,y :设置两个参数,这个思想很牛x
   # print x,y
    if y == search_value: #建立相同value对应的key_list
        key_list.append(x)
print key_list
 
5.sorted排序方法再议
在python脚本中这样写
import string #测试下不引入string时的输出情况。
a = "dcDSfag1f43"
a = ''.join([x for x in a if not x.isdigit()])
print sorted(a,key=string.upper)
执行后输出为
hong@calm:~$ python test.py
['a', 'c', 'd', 'D', 'f', 'f', 'g', 'S']
 
注意:
key=string.upper可以理解为
1.用string.upper这个方法,去执行列表中的每一个数据,假设我们有一个list
c = [a,b,c]
sorted(c,key=string.upper)相当于先生成一个新的列表
c = [string.upper(a),string.upper(b),string.upper(c)],然后对这个新的列表进行排序。
 
结论:
[x for x in a if not x.isdigt()] 等价于下面代码
   
new_list = []
for x in a:
    if not x.isdigit():
      new_list.append(x)
 
6. 好玩的translate与maketrans---替换字符
 
例子1
>>> import string
>>> g = string.maketrans('123','abc') #建立翻译表,参数中的'123'和'abc'位数必须一致,因为它是一一对应翻译的,否则会报错
>>> a = '123456'
>>> print a.translate(g)
abc456
 
例子2
>>> a = '321123132'
>>> print a.translate(g)
cbaabcacb
对比replace
>>> a.replace('123','abc')
'321abc132'
 
例子3,删除操作
>>> a = '321123132'
>>> a.translate(g,'1') #输出删除1后对应的翻译
'cbbccb'
如果不翻译,输出删除1后的结果
>>> c = string.maketrans('','')
>>> a.translate(c,'1')
'322332'
>>> a.translate(c,'12')
'333'
逐个删除。
 
7. 一个新的语句,with,一个写文件的方法
 
普通方法
g = open('a.txt','w')
g.write('hello,\nhi')
g.close()
 
with方法
with open('a.txt','a') as g: #参数a表示append
    g.write("hello")
这种方法不需要写close语句
 
 
 
 
2017/8/20 8:58
基础篇20-python函数
 
一. 定义函数
1. def是关键字,括号冒号永不忘,执行代码块要缩进
2. 没有return的函数,不是真函数
3. 不写doc的函数,就像没有性别的人类,也就是要在函数中写说明,直接在def test():下一行用双引号写下说明就行了
 
例子1
def test():
    print 4
test()
上面这个写法是错误的,应该如下写
def test():
    return 4
print test()
 
例子2
#coding=utf-8
def test():
    "这是一个测试函数"
    return 1
 
print test.__doc__  
#这个命令是直接打出函数说明信息的,也就是执行python test.py时,会输出"这是一个测试函数", 需要注意的是doc前面和后面是2个下划线。
 
 
二. 函数的参数
 
 
1) 位置参数
def test(a,b,c,d):
    return a,b,c,d #这样的结果是会返回一个元组(1,2,3,4)
 
print test(1,2,3,4) #定义的时候有几个位置参数,这里就要写几个数,否则会报错
 
 
2)可选参数,直白意思就是调用函数的时候参数写不写都行,不会报错。
def test1(a=4)
    return a
 
print test1()
输出结果是4
 
print test1(5)
输出结果是5
 
3)可选参数可以当做默认值进行设置
例子, 下面是伪代码,知道意思就好
def test2(a,b,c return_data="json"):
    if return_data == 'json':
        return json(a,b,c)
    elif return_data == 'xml':
        return xml(a,b,c)
 
    return a,b,c
 
test2(1,2,3,return_data='xml)
 
2.  参数的值是局部变量
 
1)全局变量和局部变量
 
例1,在脚本中如下写
b = 3  #全局变量
 
def a():
    #global b
    b = 4 #局部变量
    return b
 
def c():
    return b
 
print a()
print c()
 
结果输出为
4
3
 
说明在局部变量和全局变量中都定义一个变量的时候,会优先使用局部变量的值,如果局部变量没有定义,则会自动使用全局变量值
如果想在函数a中修改全局变量b的值,方法是使用global b,那么此时print c()的值也是4了,说明全局变量修改成功,这个方法慎用。
 
2)如何修改参数
 
例子
有一个list b = [1,2,3],想通过一个函数func(b),实现结果为把list b =[1,2,3,4], 方法如下
 
b = [1,2,3]
 
def func(x) #定义函数有一个参数
    x.append(4)
    return x 
 
b = func(b) 
#调用函数func,并且把返回值重新赋值给b,虽然不用赋值给b,结果也是正确的,但这不是一个好的编程习惯。
print b
 
3) 函数的参数魔法  -----   **和*   星星是字典,星是元组
 
例子1
def test(**kr):
    return kr  #kr可以是任意字符,表示字典名
 
print test(a=4,c=3)
输出结果为{'a':4, 'c':3}
 
 
例子2
def test(*z):
    return z
 
print test(1,2,[1,2])
输出结果为(1,2,[1,2])
 
例子3
def test(*z,**kr):
    return z,kr
print test(1,2,a=5,b=9)
输出结果为 ((1, 2), {'a': 5, 'b': 9})
注意:
参数a=5这样的参数必须是一起写在1,2这样的参数后面。修改test(*z,**kr)的参数位置也不行。
 
例子4
def test(a,b,*z,**kr)
    return z,kr
print test(1,2,4,5,c=4,d=9)
 
如果定义参数的时候,已经有了位置参数,那么在print test写入实参的时候是按照形参的顺序来写入的
实参中的c,d在定义中必须是没有c,d的,不然就会报错。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部