python基础

变量
<small>变量名必须是大小写英文、数字，的组合，且不能数字开头
变量本身类型不固定（动态语言）；
a = 1 ，a为整数变量；a = ‘abc’，a为字符串变量</small>
python数据类型
<small>整数，1，-100，0，0xff00，整数运算是精确的
浮点数，1.23，3.14，浮点数运算有误差
字符串，’abc’，“I’m OK”，’I\’m \“OK\”’，使用\来转义字符，也可以不转义 r’’表示’’内部的字符串不转义;’’’…’’’表示多行
布尔值，True，False
空值，None
变量，变量名必须是大小写英文，数字和的组合，且不能用数字开头，a=1;
这种变量为动态语言——本身类型不固定的语言；
常量，全部大写的变量名表示常量，PI=3.1415926，但实际PI仍然是一个变量</small>

list
<small>list是python内置的一种数据类型，列表是一种有序的集合，可以删除和添加其中的元素。

classmates = ['Kate','Lily','David’]
L = ['Apple', 10, True] # list里面的元素数据类型可以不同
s = ['python', 'java', ['asp', 'php'], 'scheme’] #list里面也可以是另一个list
classmates[0]，根据索引获取list每个位置的元素
classmates[-1]，获取list最后一个元素，依次类推classmates[-2]获取倒是第二个元素
classmates.append('Bob’), 往list中添加元素
classmates.insert(1, 'Michael’)，往指定位置插入元素
classmates.pop()，删除最后一个元素
classmates.pop(1),删除指定位置的元素
classmates[1] = ‘Tracy’,替换指定位置的元素

</small>

tuple
<small>
tuple：有序列表，类似list，但是tuple一旦初始化就不能修改
tuple不可变，代码更安全——能用tuple替代list就用tuple
陷阱：当定义一个tuple时，定义的时候，tuple的元素就必须确定下来
</small>

t = (1, 2)
print t #(1, 2)
t = ()
print t #()
t = (1, )
print t #(1, )
t = (1) #这种格式，定义的不是tuple，是1这个数，因为()既可以表示tuple又可以表示数据公式中的小括号，python规定，这种情况，按小括号进行计算
print t #1
“可变的”tuple
t = ('a', 'b', ['A', 'B'])
print t
t[2][0] = 'X'
t[2][1] = 'Y'
print t
out:————>>>>>>
('a', 'b', ['A', 'B'])
('a', 'b', ['X', 'Y'])
tuple指向的list没有变成其他的list，只是list的元素变了

<small>总结：
list和tuple是python内置的有序集合，一个可变，一个不可变，要根据实际情况使用</small>

条件判断

条件判断的完整形式：
if <条件判断1>: <执行 1>
elif <条件判断2>: <执行 2>
elif <条件判断3>: <执行 3>
else:
<执行 4>
简写：
if x:
print ’True'
x可以是非零数值、非空字符串、非空list等

if语句执行的特点：
从上往下执行，如果在某个判断上是True，执行该判断的语句，忽略掉其他的elif和else

eg：
age = 7
if age >= 18:
print 'your age is ', age
print 'adult'
else:
print 'your age is ', age
print 'teenager'
if age >= 18:
print 'adult'
elif age >= 6:
print 'teenager'
else:
print 'kids'

循环
for...in循环

names = ['Michael', 'Bob', 'Kate']
for name in names:
print name
sum1 = 0
for x in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum1 = sum1 + x
print sum1
sum2 = 0
for x in range(101):
sum2 += x
print sum2
其中，range(n)方法，是python中提供的可以生成一个整数序列[0,….,n-1]

while循环
只要条件满足就不断循环

# 100以内所有奇数之和
sum3 = 0
n = 99
while n > 0:
sum3 += n
n -= 2
print sum3
raw_input()——读取的内容以字符串的形式返回，与整数对比时，需要转换成整数类型
birth = int(raw_input('birth:'))
if birth < 2000:
print '00前'
else:
print '00后'

dict
其他语言中的map，使用键-值存储，具有极快的查找速度
dict的key必须是不可变对象

d = {'Michael': 98, 'Bob': 55, 'Tracy': 88}
print d['Michael']
d['Jack'] = 77 #add a key-value
print d['Jack']
d['Thomas'] = 100
print "Thomas' score is %d" % d['Thomas']
d.pop('Thomas’) #delete a key-value
if 'Thomas' in d: # 'Thomas' in d,查看dict中是否存在该key
print 'hahn'
else:
print 'error'
print d #output dict

和list比，dict有以下几个特点：

<small>查找和插入的速度极快,不会随着 key 的增加而增加;
需要占用大量的内存,内存浪费多。
而 list 相反:
查找和插入的时间随着元素的增加而增加;
占用空间小,浪费内存很少。
所以,dict 是用空间来换取时间的一种方法。</small>

set

set和dict类似，也是一组key的集合，但不存储value；
在set中没有重复的key

s = set([1,1,2,2,3])
s.add(5) #add()添加元素到set
s.remove(2) #remove()删除set中的元素
print s #set([1, 3, 5])

set可以看成数学意义上的无序和无重复元素的集合，因此两个结合可以做数学意义上的交集、并集等操作

s1 = set([1,2,3])
s2 = set([2,3,4])
print s1&s2 #set([2, 3])
print s1|s2 #set([1, 2, 3, 4])

函数
函数就是最基本的一种代码抽象的方式
python中的函数-》去官网看

• cmp
  比较函数

print cmp(1,2) #输出：-1
print cmp(2,1) #输出：1
print cmp(1,1) #输出：0
数据类型转换
print int(12.12) #输出：12

可以把函数名赋值给一个变量，使用变量调用函数

a = abs
print a(100)

• 定义函数

def 函数名(参数名)：
函数语句

自定义一个求绝对值的my_abs函数

def my_abs(x):
if not isinstance(x, (int, float)): #isinstance,数据类型检查
print 'aaaaaaaaaaaa'
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x

• 空函数

def nop():
pass

• 多个返回值
  python的函数返回多值其实就是返回一个tuple
  多个变量可以同时接收一个tuple，按位置赋给对应的值

def move(x1, y, step, angle=0):
nx = x1 + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx,ny
x,y = move(100,100,60,math.pi/6)
print x,y
r = move(100,100,60,math.pi/6)
print r

<small>函数总结
定义函数时，需要先确定函数名和参数个数
如果有必要，可以先对参数的数据类型做检查
函数体内部可以用return随时返回函数结果
函数执行完毕也没有return语句时，自动return None
函数可以同时返回多个值，但是就是一个tuple</small>

• 函数的参数
  函数的参数除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数
• 默认参数
  默认参数可以简化函数的调用，设置默认参数，有几点要注意：
  必选参数在前，默认参数在后，否则python编译器会报错
  如何设置默认参数
  当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面，变化小的参数就可以作为默认参数了

def enroll(name, gender, age=6, city='beijing'):
  print 'name:',name
  print 'gender:',gender
  print 'age:',age
  print 'city:',city
enroll('Lily','F')
enroll('Bob','M',10)
enroll('Michael','M','tianjin')
默认参数使用不当也会掉进坑里
def add_end(L=[]):
 L.append('END')
return L
print add_end() #输出：['END']
print add_end() #输出：[‘END’,’END']

原因是：
因为默认参数L是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了
必须要注意：
默认参数必须要指向不变对象

• 可变参数
  传入的参数个数是可变的
  可变参数可以传递0个或任意个参数

def calc(*numbers): #参数前加上*，在函数内部，参数number接收到的是一个tuple
sum = 0
for n in numbers:
sum = sum + n * n
return sum
print calc()
print calc(1,2)
如果已经有一个list或tuple，要调用一个可变参数，如下：
num = [1,2,3]
print calc(*num)

• 关键字参数
  可以传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装成一个dict

def person(name,age,**kw):
  print 'name:',name,'age:',age,'other:',kw
print person('Lily',8) #name: Lily age: 8 other: {}
print person('Bob',10,city='Beijing’) 
#name: Bob age: 10 other: {'city': 'Beijing'}
print person('Michael',30,gender='Female',city='hangzhou’) 
#name: Michael age: 30 other: {'gender': 'Female', 'city': 'hangzhou'}

如果已经有一个dict要调用一个关键字参数，如下：

dict = {‘city’:’Beijing’,’job’:’engineer'}
print person(‘Jack’,25,**dict)

• 参数组合
  在python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这四种参数都可以一起使用，但是使用的顺序必须是：必选参数-》默认参数-》可变参数-》关键字参数

def func(a , b ,c=0,*args,**kwargs):
  print 'a=',a,'b=',b,'c=',c,'args=',args,'kwargs=',kwargs
print func('a','b',10,'c','d',city='hangzhou’) #a= a b= b c= 10 args= ('c', 'd') kwargs= {'city': 'hangzhou'}

无论一个函数的参数是如何定义的，都可以通过如下这种形式来调用：```
args = (1,2,3,4)
dict1 = {'x':99}
print func(args,*dict1)

><small>函数的参数小结
默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误
定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple
**kw是关键字参数，kw接收的是一个dict
调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1,2,3)，又可以先组装list或tuple，再通过*args传入：func(*(1,2,3))
关键字参数既可以直接传入：func(a=1,b=2)，又可以先组装成dict，再通过**kw传入：func(**{‘a’:1,’b’:2})</small>