1 基本数据类型
Python 里面有自己的内置数据类型 (build-in data type),基本数据类型包含三种,分别是整型 (int),浮点型 (float),和布尔型 (bool)
1.1 整型
整数 (integer) 是最简单的数据类型,和下面浮点数的区别就是前者小数点后没有值,后者小数点后有值。
a = 205
print(a, type(a))
205 <class 'int'>
通过 print 的可看出 a 的值,以及类 (class) 是 int。Python 里面万物皆对象(object),「整数」也不例外,只要是对象,就有相应的属性 (attributes) 和方法 (methods)。
知识点:
- 通过 dir( X ) 和help( X ) 可看出 X 对应的对象里可用的属性和方法。
- X 是 int,那么就是 int 的属性和方法
- X 是 float,那么就是 float 的属性和方法
dir(int)
['__abs__',
'__add__',
'__and__',
'__bool__',
'__ceil__',
'__class__',
'__delattr__',
'__dir__',
'__divmod__',
'__doc__',
'__eq__',
'__float__',
'__floor__',
'__floordiv__',
'__format__',
'__ge__',
'__getattribute__',
'__getnewargs__',
'__gt__',
'__hash__',
'__index__',
'__init__',
'__init_subclass__',
'__int__',
'__invert__',
'__le__',
'__lshift__',
'__lt__',
'__mod__',
'__mul__',
'__ne__',
'__neg__',
'__new__',
'__or__',
'__pos__',
'__pow__',
'__radd__',
'__rand__',
'__rdivmod__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__rfloordiv__',
'__rlshift__',
'__rmod__',
'__rmul__',
'__ror__',
'__round__',
'__rpow__',
'__rrshift__',
'__rshift__',
'__rsub__',
'__rtruediv__',
'__rxor__',
'__setattr__',
'__sizeof__',
'__str__',
'__sub__',
'__subclasshook__',
'__truediv__',
'__trunc__',
'__xor__',
'bit_length',
'conjugate',
'denominator',
'from_bytes',
'imag',
'numerator',
'real',
'to_bytes']
1.2 浮点数
简单来说,浮点型 (float) 数就是实数。
print(1, type(1))
print(1.0, type(1.0))
1 <class 'int'>
1.0 <class 'float'>
加一个小数点"." 就可以创建 float。有时候我们想保留浮点型的小数点后 n 位。可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现
import decimal
from decimal import Decimal
Python 里面有很多用途广泛的包 (package),用什么你就引进 (import) 什么。包也是对象,也可以用上面提到的dir(decimal) 来看其属性和方法。比如 getcontext() 显示了 Decimal 对象的默认精度值是 28 位 (prec=28)。
decimal.getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
d = Decimal(1) / Decimal(3) # 默认保留小数后面28位
d
Decimal('0.3333333333333333333333333333')
#如果要保留 4 位,需要用 getcontext().prec 来调整精度
decimal.getcontext().prec = 4
e = Decimal(1)/Decimal(3)
e
Decimal('0.3333')
# 高精度的 float 加上低精度的 float,保持了高精度
d + e
Decimal('0.6666333333333333333333333333')
1.3 布尔型
布尔 (boolean) 型变量只能取两个值,True 和 False。当把布尔变量用在数字运算中,用 1 和 0 代表 True 和 False。
T = True
F = False
print(T + 2)
print(F - 8)
3
-8
- 除了直接给变量赋值 True 和 False,还可以用 bool(X) 来创建变量,其中 X 可以是
- 基本数据类型:整型,浮点型、布尔型
- 容器数据类型:字符,元组,列表,字典和集合
print( type(0), bool(0), bool(1) )
print( type(10.31), bool(0.00), bool(10.31) )
print( type(True), bool(False), bool(True) )
<class 'int'> False True
<class 'float'> False True
<class 'bool'> False True
bool 作用在基本类型变量的总结:X 只要不是整型 0、浮点型 0.0,bool(X) 就是 True,其余就是 False。
print( type(''), bool( '' ), bool( 'python' ) )
print( type(()), bool( () ), bool( (10,) ) )
print( type([]), bool( [] ), bool( [1,2] ) )
print( type({}), bool( {} ), bool( {'a':1, 'b':2} ) )
print( type(set()), bool( set() ), bool( {1,2} ) )
<class 'str'> False True
<class 'tuple'> False True
<class 'list'> False True
<class 'dict'> False True
<class 'set'> False True
bool 作用在容器类型变量的总结:X 只要不是空的变量,bool(X) 就是 True,其余就是 False。
知识点:
- 确定bool(X) 的值是 True 还是 False,就看 X 是不是空,空的话就是 False,不空的话就是 True。
- 对于数值变量,0, 0.0 都可认为是空的。
- 对于容器变量,里面没元素就是空的。
2 容器数据类型
整型、浮点型和布尔型都可以看成是单独数据,而这些数据都可以放在一个容器里得到一个「容器类型」的数据,比如:
- 字符 (str) 是一容器的字节 char,注意 Python 里面没有 char 类型的数据,可以把单字符的 str 当做 char。
- 元组 (tuple)、列表 (list)、字典 (dict) 和集合 (set) 是一容器的任何类型变量。
2.1 字符
字符用于处理文本 (text) 数据,用「单引号 ’」和「双引号 “」来定义都可以。
t1 = 'i love Python!'
print( t1, type(t1) )
t2 = "I love Python!"
print( t2, type(t2) )
i love Python! <class 'str'>
I love Python! <class 'str'>
- 字符中常见的内置方法 (可以用 dir(str) 来查) 有
- capitalize():大写句首的字母
- split():把句子分成单词
- find(x):找到给定词 x 在句中的索引,找不到返回 -1
- replace(x, y):把句中 x 替代成 y
- strip(x):删除句首或句末含 x 的部分
dir(str)
['__add__',
'__class__',
'__contains__',
'__delattr__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
'__getnewargs__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__iter__',
'__le__',
'__len__',
'__lt__',
'__mod__',
'__mul__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__rmod__',
'__rmul__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'capitalize',
'casefold',
'center',
'count',
'encode',
'endswith',
'expandtabs',
'find',
'format',
'format_map',
'index',
'isalnum',
'isalpha',
'isascii',
'isdecimal',
'isdigit',
'isidentifier',
'islower',
'isnumeric',
'isprintable',
'isspace',
'istitle',
'isupper',
'join',
'ljust',
'lower',
'lstrip',
'maketrans',
'partition',
'replace',
'rfind',
'rindex',
'rjust',
'rpartition',
'rsplit',
'rstrip',
'split',
'splitlines',
'startswith',
'strip',
'swapcase',
'title',
'translate',
'upper',
'zfill']
t1.capitalize()
'I love python!'
t2.split()
['I', 'love', 'Python!']
t1.find('love') # 找得到返回位置
2
t1.find('like') # 找不到返回-1
-1
t2.replace( 'love Python', 'like R' )
'I like R!'
print( 'http://www.python.org'.strip('htp:/'))
print( 'http://www.python.org'.strip('.org'))
www.python.org
http://www.python
索引和切片
s = 'Python'
print( s )
print( s[2:4] )
print( s[-5:-2] )
print( s[2] )
print( s[-1] )
Python
th
yth
t
n
Python 里面索引有三个特点 (经常让人困惑):
- 从 0 开始 (和 C 一样),不像 Matlab 从 1 开始。
- 切片通常写成 start:end 这种形式,包括「start 索引」对应的元素,不包括「end索引」对应的元素。因此 s[2:4] 只获取字符串第 3 个到第 4 个元素。
- 索引值可正可负,正索引从 0 开始,从左往右;负索引从 -1 开始,从右往左。使用负数索引时,会从最后一个元素开始计数。最后一个元素的位置编号是 -1。
与其把注意力放在元素对应的索引,不如想象将元素分开的隔栏,显然 6 个元素需要 7 个隔栏,隔栏索引也是从 0 开始,这样再看到 start:end 就认为是隔栏索引,那么获取的元素就是「隔栏 start」和「隔栏 end」之间包含的元素。如上图:
- string[2:4] 就是「隔栏 2」和「隔栏 4」之间包含的元素,即 th
- string[-5:-2] 就是「隔栏 -5」和「隔栏 -2」之间包含的元素,即 yth
正则表达式
- 正则表达式 (regular expression) 主要用于识别字符串中符合某种模式的部分。
input = """
'06/18/2019 13:00:00', 100, '1st';
'06/18/2019 13:30:00', 110, '2nd';
'06/18/2019 14:00:00', 120, '3rd'
"""
input
"\n'06/18/2019 13:00:00', 100, '1st';\n'06/18/2019 13:30:00', 110, '2nd';\n'06/18/2019 14:00:00', 120, '3rd'\n"
import re
pattern = re.compile("'[0-9/:\s]+'")
pattern.findall(input)
["'06/18/2019 13:00:00'", "'06/18/2019 13:30:00'", "'06/18/2019 14:00:00'"]
- 最外面的两个单引号 ’ 代表该模式以它们开始和结束
- 中括号 [] 用来概括该模式涵盖的所有类型的字节
- 0-9 代表数字类的字节
- / 代表正斜线
- : 代表分号
- \s 代表空格
- [] 外面的加号 + 代表 [] 里面的字节出现至少 1 次
2.2 元组
元组」定义语法为 :(元素1, 元素2, …, 元素n)
- 关键点是「小括号 ()」和「逗号 ,」
- 小括号把所有元素绑在一起
- 逗号将每个元素一一分开
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print( t1, type(t1) )
print( t2, type(t2) )
(1, 10.31, 'python') <class 'tuple'>
(1, 10.31, 'python') <class 'tuple'>
# 创建二维元组
nested = (1, 10.31, 'python'), ('data', 11)
nested
((1, 10.31, 'python'), ('data', 11))
索引和切片
元组中可以用整数来对它进行索引 (indexing) 和切片 (slicing)。一般来说,前者是获取单个元素,后者是获取一组元素。
print(nested[0])
print( nested[0][0], nested[0][1], nested[0][2] )
(1, 10.31, 'python')
1 10.31 python
nested[0][0:2]
(1, 10.31)
nested[0][0:1]
(1,)
元组有不可更改 (immutable) 的性质,因此不能直接给元组的元素赋值.
t = ('OK', [1, 2], True)
t[2] = False
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-60-2391723ab1a0> in <module>
1 t = ('OK', [1, 2], True)
----> 2 t[2] = False
TypeError: 'tuple' object does not support item assignment
但是只要元组中的元素可更改 (mutable),那么我们可以直接更改其元素,注意这跟赋值其元素不同。
t[1].append(3)
t
内置方法
元组大小和内容都不可更改,因此只有 count 和 index 两种方法。
t = (1, 10.31, 'python')
print( t.count('python') ) # 统计出现次数
print( t.index(10.31) ) # 返回元素在元组中的位置
- count(‘python’) 是记录在元组 t 中该元素出现几次,显然是 1 次
- index(10.31) 是找到该元素在元组 t 的索引,显然是 1
元组拼接
元组拼接 (concatenate) 有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。
(1, 10.31, 'python') + ('data', 11) + ('OK',)
(1, 10.31, 'python') * 2
解压元组
# 解压一维元组
t = (1, 10.31, 'python')
(a, b, c) = t
print( a, b, c )
# 解压二维元组
t = (1, 10.31, ('OK','python'))
(a, b, (c,d)) = t
print( a, b, c, d )
1 10.31 OK python
# 如果只想要元组其中几个元素,用通配符「*」,英文叫 wildcard,在计算机语言中代表一个或多个元素。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print( a, b, c )
print( rest )
1 2 5
[3, 4]
# 如果根本不在乎 rest 变量,那么就用通配符「*」加上下划线「_」
a, b, *_ = t
print( a, b )
1 2
- 优缺点
- 优点:占内存小,安全,创建遍历速度比列表快,可一赋多值。
- 缺点:不能添加和更改元素。
2.3 列表
「列表」定义语法为 [元素1, 元素2, …, 元素n]
- 关键点是「中括号 []」和「逗号 ,」
- 中括号把所有元素绑在一起
- 逗号将每个元素一一分开
l = [1, 10.31,'python']
print(l, type(l))
[1, 10.31, 'python'] <class 'list'>
内置方法
不像元组,列表内容可更改 (mutable),因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
l.append([4, 3])
print( l )
l.extend([1.5, 2.0, 'OK'])
print( l )
[1, 10.31, 'python', [4, 3]]
[1, 10.31, 'python', [4, 3], 1.5, 2.0, 'OK']
- append 是追加,把一个东西整体添加在列表后;
- extend 是扩展,把一个东西里的所有元素添加在列表后。
# 插入
l.insert(1, 'abc') # 1表示在索引为1的元素前面插入
print(l)
[1, 'abc', 10.31, 'python', [4, 3], 1.5, 2.0, 'OK']
# 删除
l.remove('python') # remove first occurrence of object
print(l)
[1, 'abc', 10.31, [4, 3], 1.5, 2.0, 'OK']
p = l.pop(3) # 从列表在去掉索引为3的元素,并返回这个元素
print( p )
print( l )
[4, 3]
[1, 'abc', 10.31, 1.5, 2.0, 'OK']
- remove是指定具体要删除的元素,比如 ‘python’
- pop是指定一个编号位置,比如 3,删除 l[3] 并返回出来.
索引和切片
l = [7, 2, 9, 10, 1, 3, 7, 2, 0, 1]
l[1:5]
[2, 9, 10, 1]
l[-4:]
[7, 2, 0, 1]
l[2:4] = [999, 10000]
l
[7, 2, 999, 10000, 1, 3, 7, 2, 0, 1]
- 切片的通用写法是:
- start : stop : step
# 情况1:start
print( l )
print( l[3:] )
print( l[-4:] )
[7, 2, 999, 10000, 1, 3, 7, 2, 0, 1]
[10000, 1, 3, 7, 2, 0, 1]
[7, 2, 0, 1]
# 情况2:stop
print( l )
print( l[:6] )
print( l[:-4] )
[7, 2, 999, 10000, 1, 3, 7, 2, 0, 1]
[7, 2, 999, 10000, 1, 3]
[7, 2, 999, 10000, 1, 3]
# 情况3:start:stop
print( l )
print( l[2:4] )
print( l[-5:-1] )
[7, 2, 999, 10000, 1, 3, 7, 2, 0, 1]
[999, 10000]
[3, 7, 2, 0]
# 情况4:start:stop;step
print( l )
print( l[1:5:2] )
print( l[:5:2] )
print( l[1::2] )
print( l[::2] )
print( l[::-1] )
[7, 2, 999, 10000, 1, 3, 7, 2, 0, 1]
[2, 10000]
[7, 999, 1]
[2, 10000, 3, 2, 1]
[7, 999, 1, 7, 0]
[1, 0, 2, 7, 3, 1, 10000, 999, 2, 7]
以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1,相当于将列表反向排列。
列表拼接
列表拼接也有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。
[1, 10.31, 'python'] + ['data', 11] + ['OK']
[1, 10.31, 'python', 'data', 11, 'OK']
[1, 10.31, 'python'] * 2
[1, 10.31, 'python', 1, 10.31, 'python']
- 优缺点
- 优点:灵活好用,可索引、可切片、可更改、可附加、可插入、可删除。
- 缺点:相比 tuple 创建和遍历速度慢,占内存。此外查找和插入时间较慢。
2.4 字典
- 「字典」定义语法为:{元素1, 元素2, …, 元素n},其中每一个元素是一个「键值对」—— 键:值 (key:value)
- 关键点是「大括号 {}」,「逗号 ,」和「分号 :」
- 大括号把所有元素绑在一起
- 逗号将每个键值对一一分开
- 分号将键和值分开
d = {
'Name' : 'Tencent',
'Country' : 'China',
'Industry' : 'Technology',
'Code': '00700.HK',
'Price' : '361 HKD'
}
print( d, type(d) )
{'Name': 'Tencent', 'Country': 'China', 'Industry': 'Technology', 'Code': '00700.HK', 'Price': '361 HKD'} <class 'dict'>
内置方法
字典里最常用的三个内置方法就是 keys(), values() 和 items(),分别是获取字典的键、值、对。
print( list(d.keys()),'\n' )
print( list(d.values()), '\n' )
print( list(d.items()) )
['Name', 'Country', 'Industry', 'Code', 'Price']
['Tencent', 'China', 'Technology', '00700.HK', '361 HKD']
[('Name', 'Tencent'), ('Country', 'China'), ('Industry', 'Technology'), ('Code', '00700.HK'), ('Price', '361 HKD')]
# 添加
d['Headquarter'] = 'Shen Zhen'
d
{'Name': 'Tencent',
'Country': 'China',
'Industry': 'Technology',
'Code': '00700.HK',
'Price': '361 HKD',
'Headquarter': 'Shen Zhen'}
# 获取
print( d['Price'] )
print( d.get('Price') )
361 HKD
361 HKD
# 更新(赋值)
d['Price'] = '359 HKD'
d
{'Name': 'Tencent',
'Country': 'China',
'Industry': 'Technology',
'Code': '00700.HK',
'Price': '359 HKD',
'Headquarter': 'Shen Zhen'}
# 删除
del d['Code']
d
{'Name': 'Tencent',
'Country': 'China',
'Industry': 'Technology',
'Price': '359 HKD',
'Headquarter': 'Shen Zhen'}
# pop() 函数
print( d.pop('Industry') )
d
Technology
{'Name': 'Tencent',
'Country': 'China',
'Price': '359 HKD',
'Headquarter': 'Shen Zhen'}
不可更改键
- 字典里的键是不可更改的,因此只有那些不可更改的数据类型才能当键,比如整数、浮点数、布尔、字符、元组,而列表却不行,因为它可更改。
d = {
2 : 'integer key',
10.31 : 'float key',
True : 'boolean key',
('OK',3) : 'tuple key'
}
d
{2: 'integer key',
10.31: 'float key',
True: 'boolean key',
('OK', 3): 'tuple key'}
# True 其实和整数 1 是一样的,由于键不能重复,当你把 2 该成 1时,字典只会取其中一个键。
d = {
1 : 'integer key',
10.31 : 'float key',
True : 'boolean key',
('OK',3) : 'tuple key'
}
d
{1: 'boolean key', 10.31: 'float key', ('OK', 3): 'tuple key'}
- 如何快速判断一个数据类型 X 是不是可更改的呢?
- 麻烦方法:用 id(X) 函数,对 X 进行某种操作,比较操作前后的 id,如果不一样,则 X 不可更改,如果一样,则 X 可更改。
- 便捷方法:用 hash(X),只要不报错,证明 X 可被哈希,即不可更改,反过来不可被哈希,即可更改。
i = 1
print( id(i) )
i = i + 2
print( id(i) )
# 整数 i 在加 1 之后的 id 和之前不一样,因此加完之后的这个 i (虽然名字没变),但是不是加前的那个 i 了,因此整数是不可更改的。
140735306904400
140735306904464
l = [1, 2]
print( id(l) )
l.append('Python')
print( id(l) )
#列表 l 在附加 'Python' 之后的 id 和之前一样,因此列表是可更改的。
2101930268040
2101930268040
hash('Name')
-5978476979602947836
hash( (1,2,'Python') )
1852668959836117693
hash( [1,2,'Python'] )
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-91-54c2881f2699> in <module>
----> 1 hash( [1,2,'Python'] )
TypeError: unhashable type: 'list'
字符 s 和元组 t 都能被哈希,因此它们是不可更改的。列表 l 不能被哈希,因此它是可更改的。
- 优缺点
- 优点:查找和插入速度快
- 缺点:占内存大
2.5 集合
创建集合
「集合」有两种定义语法
- 第一种是:{元素1, 元素2, …, 元素n},关键点是「大括号 {}」和「逗号 ,」
- 大括号把所有元素绑在一起
- 逗号将每个元素一一分开
- 第二种是用 set() 函数,把列表或元组转换成集合。
# set( 列表 或 元组 )
A = set(['u', 'd', 'ud', 'du', 'd', 'du']) # 列表
B = {'d', 'dd', 'uu', 'u'} # 元组
print( A )
print( B )
{'u', 'du', 'ud', 'd'}
{'d', 'dd', 'u', 'uu'}
从 A 的结果发现集合的两个特点:
- 无序 (unordered)
- 唯一 (unique)
由于 set 存储的是无序集合,所以没法通过索引来访问,但是可以判断一个元素是否在集合中。
B[1]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-93-ee721d8948fe> in <module>
----> 1 B[1]
TypeError: 'set' object does not support indexing
'u' in B
True
内置方法
用 set 的内置方法就把它当成是数学上的集,那么并集、交集、差集都可以使用。
- 并集:union()
- 交集:intersection()
- 差集:difference()
- 对称差集:symmetric_difference()
# 并集 OR
print( A.union(B) ) # All unique elements in A or B
print( A | B ) # A OR B
{'du', 'ud', 'u', 'dd', 'd', 'uu'}
{'du', 'ud', 'u', 'dd', 'd', 'uu'}
# 交集 AND
print( A.intersection(B) ) # All elements in both A and B
print( A & B ) # A AND B
{'d', 'u'}
{'d', 'u'}
# 差集 A - B
print( A.difference(B) ) # Elements in A but not in B
print( A - B ) # A MINUS B
{'du', 'ud'}
{'du', 'ud'}
# 差集 B - A
print( B.difference(A) ) # Elements in B but not in A
print( B - A ) # B MINUS A
{'dd', 'uu'}
{'dd', 'uu'}
# 对称差集XOR
print( A.symmetric_difference(B) ) # All elements in either A or B, but not both
print( A ^ B ) # A XOR B
{'du', 'ud', 'dd', 'uu'}
{'du', 'ud', 'dd', 'uu'}
- 优缺点
- 优点:不用判断重复的元素
- 缺点:不能存储可变对象
3 条件语句&迭代循环
- 条件语句 (conditional statement) :在不同条件下完成不同动作
- 迭代循环 (iterative loop):重复的完成某些动作
3.1 条件语句
条件语句大体有四种格式:
- if 语句
- if-else 语句
- if-elif-else 语句
- nested 语句
x = 1
# 给定二元条件,满足做事,不满足不做事。
if x > 0:
print( 'x is positive' )
x is positive
# 给定二元条件,满足做事 A,不满足做事 B。
if x % 2 == 0:
print( 'x is even' )
else :
print( 'x is odd' )
x is odd
x = 1
y = 1.0
# 给定多元条件,满足条件 1 做事 A1,满足条件 2 做事 A2,..., 满足条件 n 做事 An。直到把所有条件遍历完。
if x < y:
print( 'x is less than y' )
elif x > y:
print( 'x is greater than y' )
else:
print( 'x and y are equal' )
x and y are equal
'''
给定多元条件,满足条件 1 做事 A1,不满足就
给定多元条件,满足条件 2 做事 A2,不满足就
...
直到把所有条件遍历完。
'''
if x == y:
print( 'x and y are equal' )
else:
if x < y:
print( 'x is less than y' )
else:
print( 'x is greater than y' )
x and y are equal
3.2 迭代循环
对于迭代循环,Python 里面有「while 循环」和「for 循环」
# Wihle循环
n = 5
while n > 0:
print(n)
n = n-1
print('I love Python')
5
4
3
2
1
I love Python
While 循环非常简单,做事直到 while 后面的语句为 False。
# For循环
languages = ['Python', 'R', 'Matlab', 'C++']
for language in languages:
print( 'I love', language )
print( 'Done!' )
I love Python
I love R
I love Matlab
I love C++
Done!
Python 里面的「for 循环」很像读英文。通用形式的 for loop 如下:
for a in A
do something with a
其中 for 和 in 是关键词,A 是个可迭代数据 (list, tuple, dic, set),a 是 A 里面的每个元素
enumerate 函数
enumerate(A) 不仅可以 A 中的元素,还顺便给该元素一个索引值 (默认从 0 开始)。此外,用 enumerate(A, j) 还可以确定索引起始值为 j
for i, a in enumerate(A)
do something with a and i
languages = ['Python', 'R', 'Matlab', 'C++']
for i, language in enumerate(languages, 1):
print( i,',', 'I love', language )
print( 'Done!' )
1 , I love Python
2 , I love R
3 , I love Matlab
4 , I love C++
Done!
4 总结
学习任何一种都要从最基本开始,基本的东西无外乎“数据类型”、“条件语句”和“递推循环”。
- 数据类型分两种:
- 单独类型:整型、浮点型、布尔型
- 容器类型:字符、元组、列表、字典、集合
按照 Python 里「万物皆对象」的思路,学习每一个对象里面的属性 (attributes) 和方法 (methods),你不需要记住所有,有个大概印象有哪些,通过 dir() 来锁定具体表达式,再去官网上查询所有细节。这么学真的很系统而简单。此外学的时候一定要带着“它的优缺点是什么”这样的问题,所有东西都有 trade-off,一个满身都是缺点的东西就没有存在的必要,既然存在肯定有可取之处。
- 条件语句 (if, if-else, if-elif-else, nested if) 是为了在不同条件下执行不同操作,
- 迭代循环 (while, for) 是重复的完成相同操作。