python语法

# -*- coding: utf-8 -*-
#由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：


#!/usr/bin/env python
# -*- coding: utf-8 -*-
#第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
#第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。


# output
print 'hello world'
#连续输出
print 'I','Love','Football'


# input
name = raw_input('please enter your name:')
print 'name:',name
# type:判断变量类型
print type(name)
#从raw_input()读取的内容永远以字符串的形式返回,想得到整数的话，先用int()转换
birth = int(raw_input('birth:'))
print birth
birth = str(birth)


# True,False,None


print 10/3
print 10.0/3
print 10%3


# ord,chr:把字母和对应的数字相互转换
print ord('A')
print chr(65)


# u:unicode字符串
print u'中文'


#len:返回字符串长度
print len('adw')


#格式化方式和C语言是一致的，用%实现
print 'Hello,%s' % 'world'
print 'Hi,%s,you have $%d.' % ('wade',10000)
'''
常见的占位符有：
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
'''
# list:一种有序的集合，可以随时添加和删除其中的元素。
classmates = ['machal','bob','tracy']
print classmates
# len 可以获得list元素个数
print len(classmates)
#用索引来访问list中每一个位置的元素，记得索引是从0开始的
print classmates[0]
#如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：
print classmates[-1]
#list是一个可变的有序表，所以，可以往list中追加元素到末尾
classmates.append('Adam')
print classmates
#也可以把元素插入到指定的位置，比如索引号为1的位置
classmates.insert(1,"Jack")
print classmates
#要删除list末尾的元素，用pop()方法
#要删除指定位置的元素，用pop(i)方法，其中i是索引位置
#要把某个元素替换成别的元素，可以直接赋值给对应的索引位置
classmates[1] = 'sarah'
#list里面的元素的数据类型也可以不同
#list元素也可以是另一个list


# tuple:和list非常类似，但是tuple一旦初始化就不能修改
# tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来
t = (1,2)
#因为括号()既可以表示tuple，又可以表示数学公式中的小括号
#所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
t = (1,)


# if
a = 100
if a >= 0:
print a
else:
print a
'''
完整形式：
if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>
'''


# for...in循环
for name in classmates:
print name


# while循环
s = 0
n = 99
while n > 0:
s = s + n
n = n - 2
print s


# dict:Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度
d = {'michal':95,'bob':75,'tracy':85}
print d['bob']
#由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉
#如果key不存在，dict就会报错
#要避免key不存在的错误，有两种办法，一是通过in判断key是否存在
print 'tom' in d
#二是通过dict提供的get方法，如果key不存在，可以返回None
print d.get('tom')
#要删除一个key，用pop(key)方法，对应的value也会从dict中删除
'''
和list比较，dict有以下几个特点：


查找和插入的速度极快，不会随着key的增加而增加；
需要占用大量的内存，内存浪费多。
而list相反：


查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
'''
#需要牢记的第一条就是dict的key必须是不可变对象。
#在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key


# set:和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key
# 要创建一个set，需要提供一个list作为输入集合
s = set([1,2,3])
print s
#通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果
s.add(4)
#通过remove(key)方法可以删除元素
s.remove(4)
#set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作


#再议不可变对象
#对于可变对象，比如list，对list进行操作，list内部的内容是会变化的
a = ['c','b','a']
a.sort()
print a
#对于不可变对象,例如str
a = 'abc'
b = a.replace('a','A')
print a,b


#定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回
def my_abs(x):
if x >= 0:
return x
else:
return -x
print my_abs(-3)
#如果想定义一个什么事也不做的空函数，可以用pass语句
age = 19
if age >= 18:
pass


#参数检查:调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError
#对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance实现
def my_abs1(x):
if not isinstance(x,(int,float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
#函数可以返回多个值，其实就是返回一个tuple
#可变参数
def calc(*numbers):
sum1 = 0
for n in numbers:
sum1 = sum1 + n*n
return sum1
#调用该函数时，可以传入任意个参数，包括0个参数
calc(1,2)
#关键字参数
#关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def person(name,age,**kw):
print 'name:',name,"age:",age,'other:',kw


#切片
#取前N个元素，也就是索引为0-(N-1)的元素,用到切片（Slice）操作符
L = ['a','b','c','d']
print L[0:3]
#L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
#如果第一个索引是0，还可以省略


#也可以从索引1开始，取出2个元素出来
print L[1:3]
#L[-1]取倒数第一个元素，那么它同样支持倒数切片
#字符串'xxx'或Unicode字符串u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串
print 'abcdefg'[:3]


#如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（Iteration）
d = {'a':1,'b':2,"c":3}
for key in d:
print key
#默认情况下，dict迭代的是key,如果要迭代value,可以用for value in d.itervalues()
#如果要同时迭代key和value，可以用for k,v in d.iteritems
for k,v in d.iteritems():
print k,v
#判断一个对象是否是可迭代对象：
from collections import Iterable
print isinstance(d,Iterable)
#enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身
for i,value in enumerate(['A','B','C']):
print i,value


# 列表生成式
#要生成list[1,2,3,4,5,6,7,8,9,10],可以用range(1,11)
print range(1,11)
#生成[1*1,2*2,...,10*10]
print [x*x for x in range(1,11)]
#后面还可以加上if判断，[x * x for x in range(1, 11) if x % 2 == 0]
#可以使用两层循环生成全排列，[m+n for m in 'ABC' for n in 'XYZ']
#列出当前目录下的所有文件和目录名
import os
print [d for d in os.listdir(".")]
#把所有字符串变成小写
L = ['Hello','World','IBM','Apple']
print [s.lower() for s in L]


# 生成器generator：不必创建完整的list，一边循环一边计算的机制
#创建generator,一种方式把列表生成式[]改成（）
g = (x*x for x in range(10))
for n in g:
print n
#另一种方式，如果一个函数中包含yield关键字，那么这个函数不再是一个普通函数，而是一个generator
'''
generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回
的yield语句处继续执行。


'''


# map():函数接受两个参数，一个是函数，一个是序列，将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回
def f(x):
return x*x
print map(f,[1,2,3,4,5,6,7,8,9])


# reduce():同样也是一个函数，一个序列，，这个函数必须接受两个参数，把结果继续和下一个元素做累计计算
def add(x,y):
return x+y
print reduce(add,[1,2,3,4,5,6,7,8,9])


#排序
#sorted():函数可以对list进行排序
print sorted([32,14,5,9,10])
#高阶函数：把函数作为参数传入，或者把函数作为返回值返回


#匿名函数，因为函数没有名字，不必担心函数名冲突，关键字lambda表示匿名函数
f = lambda x: x*x
print f(1)