这是一些自己在看python时了解到的知识，蜻蜓点水过一遍，估计也只有自己能看得懂...以后碰到问题再具体分析吧。
About python I should know :
1.Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。它的定位是“简单、优雅、尽量少写代码”，目前在用的有youtube，instagram，豆瓣（不过之前有看到豆瓣员工的一篇文章说到，自从python狂热粉某某走后，现在开始java了）。开发领域：网站架构，后台服务；日常工具，脚本之类的。缺点：因为是解释性语言，代码要翻译成机器码，运行速度慢。
3. Linux自带python，whereis python查看执行目录。进入“>>>”界面，源代码每输入一行就执行一行。用vim编写，执行时在当前目录”python test.py”即可，统一执行。
4. Python 不像c语言有（）的表示方法，而是采用缩进的方式（TAB键），但坑爹的是不能再复制粘贴了，每次的缩进都不一样…会出现invalid syntax python、IndentationError: unexpected indent错误，真是太特么严格了…刚接触的人不被坑个几次你绝对感觉不到这恨是有多深。
5.python对大小写敏感
7.python数据类型：int,float,”XX”字符串.转义字符：\n换行；\t制表符，布尔值True orFalse（and,or,not运算），None空值。
8.格式化字符串：’hello, %s’ % ‘world’，%运算符是用来格式化字符串的，字符串内部，%s表示用字符串替换，%d表示用整数替换，%？表示几个占位符，不记得用什么就用%s好了。
9.List(有点像C中的数组，其中的元素可有不同的数据类型)：classmates = [‘joe’,’jimmy’,’tom’，123，True,[‘hello’,’what’],12345]
1)用len(classsmates)可算数组长度，classmates[-1]取最后一个元素，不能越界啊。
2)Classmates.append(‘Adam’),追加到list末尾
3)Classmates.insert(1,’jack’)插入指定位置
4)Classmates.pop() \n ‘Adam’ 删除list末尾；删除指定元素pop(i).
5)不能通过a_list[] = fx()的方式将函数值导入其中。
10. tuple:赋值后不可改变的”list”，不能append(),insert()，定义只有一个元素的表t= (1，) tuple所谓的“不变”是说：tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
11.if,else的例子：
age = 20
if age >= 6:
print 'teenager'
elif age >= 18:
print 'adult'
else:
print 'kid'
这个例子打印出来的是’teenager’，从上到下判断为true则执行语句，完毕。
12.循环的例子：
for）
sum = 0
for x in range(101):
sum = sum + x
print sum
while)
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print sum
3.raw_input()输入：
birth = raw_input(‘birth:’)
if birth < 2000:
print’00前’
else:
print’00后’
默认输入的是字符串，和整数比当然比较大，要强行格式转换：
Birth = int(raw_input(‘birth:’))
4.字典dict，即key/value一一对应的索引查询
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael']
95
查找和插入的速度极快，不会随着key的增加而增加；需要占用大量的内存，内存浪费多。通过set（[1,2,2,3,3,4]）可以过滤重复元素，因为key是唯一的。对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
set转成list方法如下： list转成set方法如下：
s =set('12342212') l = ['12342212']
print s # set(['1', '3', '2','4']) s = set(l[0])
l =list(s) prints # set(['1', '3', '2', '4'])
l.sort() # 排序 m= ['11','22','33','44','11','22']
print l # ['1', '2', '3','4'] printset(m) # set(['11', '33', '44', '22'])
15.函数调用： TypeError，传入的参数不对
16.定义函数：def my_abs(x):。定义空函数：def nop():pass，空函数用来做占位符，还没想好函数怎么写就先放一个pass，让其他代码能运行
-----------------如何把自己定义的函数在command下运行：假设写了一个f()在hello.py里面，在同一目录下进入python
>>>importhello (不加.py)
>>>hello.f()
此外，def这样的python关键字也不能作为文件名
17.默认参数的设置可以减少不必要的输入。
import math
def enroll(name,gender,age=6,city='hangzhou'):
print 'name:',name
print 'gender:',gender
print 'city',city
print 'age',age
enroll('bob','M')
enroll('alice','M',age=7,city='beijing')
默认参数必须要指向不变的值，否则在多次调用后，其默认的参数内容会随之改变。
可变参数：在list 或tuple的参数前加*
cals(*nums)
关键字参数：可填可不填的信息。**kw 接受的是一个dict
参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数
>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}
18.递归函数：函数一层层包裹，但这种方式可能导致栈溢出（函数调用是通过“栈”的数据结构实现的），需要做尾递归优化：函数仅返回自身，而不是返回函数（函数）的包裹形式，需要对返回函数的参数值先进行处理。
deffact(n):
return fact_iter(1, 1, n)
deffact_iter(product, count, max):
if count > max:
return product
return fact_iter(product * count, count +1, max)
19.list = range(1,100,2) >>>>>>>得到一个奇数表，牛逼得不行..这个简单
20.切片功能，即在表中进行分段的取值L[2:15]把第3到16的数据取出来，L[::5]隔5取1。L[-9]从后面开始取
21.For循环迭代，不需要像C语言一样有下标[i]，可以对key/value迭代
For I,value inenumerate([‘A’,’B’,’C’]):
Print I,value
0 A
1 B
2 C
22.列表生成式：range(1,100,2)。Isinstance(x,str)判断一个变量是不是字符串
23.如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator），就是一个装载算法的容器，变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行
def fib(max):
n, a, b = 0, 0, 1
whilen < max:
yield b
a, b = b, a + b
n= n + 1
要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。
24.Mapreduce:大小写
deff(s):
return s[0].upper() + s[1:].lower()
print map(f,['adam','LIISA','barT'])
map,其实就是分发机制，reduce则是一种递归。
25.filter,sorted,返回函数，闭包。
26.关键字lambda表示匿名函数，冒号前面的x表示函数参数
map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8,9])
lambda x: x*x = def f(x): return x*x
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
F = lambda x:x*x
F(5)
27.装饰器，偏函数（待研究）
28.模块（文件）就是把相应的函数操作打包封装起来，之后可以直接调用：
#!/usr/bin/env python
#-*- coding: utf – 8 -*-
‘atest module’
_author_= ‘Michael Fei’
Import sys(内置的sys)
deftest():
args = sys.argv
if len(args)==1:
print ‘Hello,world!’
elif len(args)==2:
print ‘Hello,%s!’ % args[1]
else:
print ‘too many arguments!’
if_name_==’_main_’:
test()
sys模块有一个argv变量，用list存储了命令行的所有参数。argv至少有一个元素，因为第一个参数永远是该.py文件的名称，例如：运行python hello.py Michael获得的sys.argv就是['hello.py', 'Michael]。
29._future_模块：由于Python是由社区推动的开源并且免费的开发语言，不受商业公司控制，因此，Python的改进往往比较激进，不兼容的情况时有发生。Python为了确保你能顺利过渡到新版本，特别提供了__future__模块，让你在旧的版本中试验新版本的一些特性。
30.面向过程和面向对象：
Student1={‘name’:’michael’,’score’:98}
Student2={‘name’:’bob’,’score’:81}
Defprint_score(std):
Print‘%s:%s’ % (student[‘name’],students[‘score’])
面向对象，首先思考的不是程序的执行流程，而是student这种数据类型首先被视作一个对象，拥有name和score两个属性，创建对象后，给对象发一个print-score消息，让对象自己把数据打印出来：
Classstudent(object):
Def_init_(self,name,score):
Self.name= name
Self.score= score
Defprint_score(self):
Print‘%s:%s’ % (self.name,self.score)
给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法。
Bart= student(‘bart simpson’,59)
List= student(‘list simpson’,87)
Bart.print_score()
List.print_score()
附上一个百度经验的python基础教程专题：python基本教程
扫一扫
584
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
