Python基础(一)
Python中数据类型
在Python中，能够直接处理的数据类型有：整数、浮点数、字符串、布尔值、空值None
Python print
print 'hello, world'print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出(相当于Java中的+号)
print 'The quick brown fox', 'jumps over', 'the lazy dog'Python变量
在Python程序中，变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头，比如：a = 1，a就是一个整数，a = ‘我’,a就是一个字符串
当我们写：a = ‘ABC’时，Python解释器干了两件事情：
在内存中创建了一个’ABC’的字符串；
在内存中创建了一个名为a的变量，并把它指向’ABC’。
也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据
Python定义字符串
字符串本身包含’怎么办？比如我们要表示字符串 I’m OK ，这时，可以用” “括起来表示：
“I’m OK”
类似的，如果字符串包含”，我们就可以用’ ‘括起来表示：
‘Learn “Python” in imooc’
如果字符串既包含’又包含”怎么办？
这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\进行转义。
要表示字符串 Bob said “I’m OK”.
我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为
‘Bob said \”I\’m OK\”.’
常用的转义字符还有：
\n 表示换行
\t 表示一个制表符
\ 表示 \ 字符本身
Python中raw字符串与多行字符串
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。
如果要表示多行字符串，可以用”’…”’表示：
'''Line 1
Line 2
Line 3'''Python中Unicode字符串
Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u’…’表示，比如：
print u'中文'
中文如果不加u，中文就不能正常显示。
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释
# -*- coding: utf-8 -*-Python中布尔类型运算
与运算 and； 或运算 or； 非运算 not；
Python把0、空字符串’ ‘和None看成 False，其他数值和非空字符串都看成True
短路计算：
在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
Python创建list
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
>>> classmates = ['Michael', 'Bob', 'Tracy']构造list非常简单，按照上面的代码，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list
由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：
>>> L = ['Michael', 100, True]Python数组添加新元素
- 使用append()方法将新元素添加到list的尾部
- 使用insert()方法，它有两个参数，第一个是索引号，第二个是要添加的新元素。
Python数组删除元素
- pop() 方法删除list的最后一个元素
- pop(2) 带索引删除
Python创建tuple
tuple是一种有序列表，元组。tuple和list非常相似，但是tuple一旦创建就不能再做修改。
>>> t = ('Adam', 'Lisa', 'Bart')tuple使用()代替了[]。现在这个t就无法再做任何修改了。
创建单元素tuple时要多加一个逗号’,’
>>> t = (1,)
>>> print t
(1,)Python可变的tuple
>>> t = ('a', 'b', ['A', 'B'])t 有 3 个元素：’a’，’b’和一个list：[‘A’, ‘B’]。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到,我们把list的两个元素改一改,再看tuple中的元素。
>>> L = t[2]
>>> L[0] = 'X'
>>> L[1] = 'Y'
>>> print t
('a', 'b', ['X', 'Y'])表面上看，tuple的元素确实变了，但其实变的不是 tuple 的元素，而是list的元素。
Python if语句
age = 20
if age >= 18:
print 'your age is', age
print 'adult'
print 'END'注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块，上面的3，4行 print 语句就构成一个代码块（但不包括第5行的print）。如果 if 语句判断为 True，就会执行这个代码块。
缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
if age >= 18:
print 'adult'
else:
print 'teenager'要避免嵌套结构的 if … else …，我们可以用 if … 多个elif … else … 的结构，一次写完所有的规则，elif 意思就是 else if。
if age >= 18:
print 'adult'
elif age >= 6:
print 'teenager'
elif age >= 3:
print 'kid'
else:
print 'baby'Python for循环
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print namePython dict
相当于Java中的Map，Key-Value，根绝Key查找Value
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}可以使用d[key]查找相应的Value。如果key不存在，就会报keyError的错误。
判断key是否存在
if 'Paul' in d: print d['Paul']使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：
>>> print d.get('Bart') 59 >>> print d.get('Paul') None
dict的特点：
- 查找速度快
- 存储的key-value序对是没有顺序的
- 作为 key 的元素必须不可变
{
'123': [1, 2, 3], # key 是 str，value是list
123: '123', # key 是 int，value 是 str
('a', 'b'): True # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean
}遍历dict
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
for key in d:
print key+':',d.get(key)Python中什么是set
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。set会自动去掉重复的元素。
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
>>> s = set(['A', 'B', 'C'])访问set中的元素使用in操作符进行判断
>>> 'A' in s
Trueset存储的元素和dict的key类似，必须是不变对象
如果事先创建好一个set，包含’MON’ ~ ‘SUN’：
weekdays = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])再判断输入是否有效，只需要判断该字符串是否在set中：
x = '???' # 用户输入的字符串
if x in weekdays:
print 'input ok'
else:
print 'input error'添加元素时，用set的add()方法，删除set中的元素时，用set的remove()方法。
Python函数
定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
def my_abs(x):
if x >= 0:
return x
else:
return -x如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。
return None可以简写为return。
Python函数可以返回多个值
import math
def move(x, y, step, angle):
nx = x + 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
151.961524227 70.0>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)其实这只是一种假象，Python函数返回的仍然是单一值,返回值是一个tuple。
定义函数的时候，还可以有默认参数。
函数的默认参数的作用是简化调用，你只需要把必须的参数传进去。但是在需要的时候，又可以传入额外的参数来覆盖默认参数值。
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s>>> power(2)
4
>>> power(2,3)
8由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：
# OK:
def fn1(a, b=1, c=2):
pass
# Error:
def fn2(a=1, b):
pass如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
def fn(*args):
print argsPython 对list进行切片
一个list如下：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']取前3个元素
Python提供了切片（Slice）操作符
>>> L[0:3]
['Adam', 'Lisa', 'Bart']L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
只用一个 : ，表示从头到尾
切片操作还可以指定第三个参数,第三个参数表示每N个取一个
>>> L[::2]
['Adam', 'Bart']例子：
range()函数可以创建一个数列：
>>> range(1, 101)
[1, 2, 3, ..., 100]请利用切片，取出：
- 前10个数；
- 3的倍数；
- 不大于50的5的倍数。
L = range(1, 101)
print L[0:10]
print L[2::3]
print L[4:50:5]同时也可以对字符串进行切片
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'索引迭代
对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，怎么办？
方法是使用 enumerate() 函数：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
... print index, '-', name
...
0 - Adam
1 - Lisa
2 - Bart
3 - Paul实际上，enumerate() 函数把：
['Adam', 'Lisa', 'Bart', 'Paul']变成了
[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]因此，迭代的每一个元素实际上是一个tuple
for t in enumerate(L):
index = t[0]
name = t[1]
print index, '-', name迭代dict的value
dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value
dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样
那这两个方法有何不同之处呢？
values() 方法实际上把一个 dict 转换成了包含 value 的list。
但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
打印 itervalues() 发现它返回一个 对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。
在一个 for 循环中，能否同时迭代 key和value?
我们看看 dict 对象的 items() 方法返回的值：
>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：
>>> for key, value in d.items():
... print key, ':', value
...
Lisa : 85
Adam : 95
Bart : 59和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
生成列表
要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)
如果要生成[1x1, 2x2, 3x3, …, 10x10]怎么做？
列表生成式则可以用一行语句代替循环生成上面的list
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]如果我们只想要偶数的平方，不改动 range()的情况下，可以加上 if 来筛选：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]复杂表达式
假设有如下的dict：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }完全可以通过一个复杂的列表生成式把它变成一个 HTML 表格：
tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
print '<table>'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>'注：字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。
把打印出来的结果保存为一个html文件，就可以在浏览器中看到效果了：
<table border="1">
<tr><th>Name</th><th>Score</th><tr>
<tr><td>Lisa</td><td>85</td></tr>
<tr><td>Adam</td><td>95</td></tr>
<tr><td>Bart</td><td>59</td></tr>
</table>多层表达式
for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']利用 3 层for循环的列表生成式，找出对称的 3 位数。例如，121 就是对称数，因为从右到左倒过来还是 121。
[100*a+10*b+c for a in range(1,10) for b in range(10) for c in range(10) if a == c]
扫一扫
1196
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
