基本数据类型

• int
• float
• string

重要数据类型

String字符串

创建字符串，单引号和双引号都可以

var1 = 'hello world'
var2 = "runoob"

截取字符串

变量[头下标:尾下标]
需要注意的是，截取的数据是从“头下标”到“尾下标的前一位”。下标从左开始，则是从0开始递增；从右开始，则是从-1开始递减。

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])


结果
var1[0]:  H
var2[1:5]:  unoo

字符串可以直接使用“+”拼接

List列表

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推;索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

#!/usr/bin/python3
 
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
 
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])


list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

更新列表

append()

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
 
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)


第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

删除列表元素

list = ['Google','Runoob',1997,2000]
del list[2]
print("删除第三个元素 : ", list)


原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

常用函数

• len(list) 返回列表元素个数
• max(list) 返回列表元素最大值
• min(list) 返回列表元素最小值
• list(seq) 将元组转化为列表

常用方法

• list.append(obj) 在列表末尾添加新的对象
• list.count(obj) 统计某个元素在列表中出现的次数
• list.extend(seq) 在列表的末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
• list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
• list.insert(index, obj) 将对象插入列表
• list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
• list.remove(obj) 移除列表中某个值的第一个匹配项
• list.reverse() 反向列表中元素
• list.sort(key=None, reverse=False) 对原列表进行排序
• list.clear() 清空列表
• list.copy() 复制列表

Tuple元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号 ( )，列表使用方括号 [ ]。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

创建空元组

tup1 = ()

注意，元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

修改元组

元组中的元素值是不允许修改的，但是可以元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

所谓元组的不可变指的是元组所指向的内存中的内容不可变。重新赋值的元组tup，绑定到新的对象了，不是修改了原来的对象。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

常用函数

• len(tuple) 计算元组元素个数
• max(tuple)
• min(tuple)
• tuple(iterable)

Dictionary字典

格式：d = {key1 : value1, key2 : value2, key3 : value3 }

tinydict = {'name': 'runoob','likes': 123,'url': 'www.runoob.com'}

创建空字典

emptyDict = {}
emptyDict = dict()

访问字典里的值

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

修改字典

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School']

常用函数

• len(dict) 计算字典元素个数，即键的总数
• str(dict) 输出字典，可以打印的字符串表示
• type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型

常用方法

• dict.clear() 删除字典内的所有元素
• key in dict 如果键在字典dict里返回true，否则返回false

Set集合

创建集合，需要注意的是，集合自带去重功能，重复的元素将不会被显示

parame = {val1,var2,...}
set(value)
#创建空集合
set()

常用方法

• set.add(x)
• set.remove(x)
• set.clear()

条件控制

一般形式

if conditon_1:
    statement_block_1
elif condition2:
    statement_block_2
else:
    statement_block_3

循环语句

while

while conditions:
    statements

count = 0
while count < 5:
    print (count, "小于5")
    count = count + 1
else
    print (count, "大于或等于5")

for

for var in seq:
    statement
else
    statement

range函数

>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

指定循环的区间，注意，仍然知道范围的前一个数

>>>for i in range(5,9) :
    print(i)
 
    
5
6
7
8
>>>

制定具体的步长

>>>for i in range(0, 10, 3) :
    print(i)
 
    
0
3
6
9
>>>

函数

语法

def 函数名（参数列表）:
    函数体

#!/usr/bin/python3
 
def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

lambda函数（匿名函数）

语法

lambda [arg1 [,arg2,.....argn]]:expression

x = lambda a : a + 10
print(x(5))

map()

语法

map(函数名，一个或多个序列)
结果返回到迭代器

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
mod2_all = map(lambda a: a%2, numbers)
out = list(mod2_all)#输出结果需要转化为列表才能显示
print(out)

filter()

语法

用于滤掉特定元素
filter(函数，序列)
结果返回到迭代器

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even = filter(lambda a: a%2 == 0,numbers)
print(list(even))

reduce()

用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

import numpy as np
from functools import reduce

np.random.seed(123)
numbers = np.random.randint(0,5,size=(10,))
print(numbers)

c = reduce(lambda x, y: x+y,numbers)#实现累加求和
print(c)

d = reduce(lambda x, y: x if x<y else   y, numbers)
print(d)

文件处理

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()