内容
1 基础数据类型
2 循环
3 条件判断
4 函数
5 切片
6 列表生成式
7 列表生成器
8 迭代对象和迭代器
1 基础数据类型
Python的基础数据类型可以分为：数字、字符串、浮点数、布尔； 基本数据结构有：list(列表)， tuple(元祖), dict(字典，java中map)和set;
可变数据类型： list dict set；
不可变数据类型： 数字 字符串 tuple
list基本使用：
// 定义
>>> a = ["xiaoming", "xiaohua"]
>>> a[0]
'xiaoming'
// 获取最后一个
>>> a[-1]
'xiaohua'
// 添加
>>> a.append("xiaohong")
>>> a
['xiaoming', 'xiaohua', 'xiaohong']
>>>
// 删除最后一个
>>> a.pop()
'xiaohong'
>>> a
['xiaoming', 'xiaohua']
>>>
// 列表长度
>>> len(a)
2
// python列表元素可以类型不一样，还可以嵌套其他列表(就是这么放荡不羁！)
>>> b = [1, "yaya", a]
>>> b
[1, 'yaya', ['xiaoming', 'xiaohua']]
tuple:
tuple是不可变类型对象，一经定义不可改变，所以tuple没有append()、pop()等方法；
// 定义
>>> t = (1,2,3)
>>> t
(1, 2, 3)
// 定义空tuple
>>> t = ()
>>> t
()
// 定义只有一个元素tuple，注意必须要有逗号，如果没有逗号python语言认为是这是整数1;
>>> t = (1,)
>>> t
(1,)
dict:
// 定义
>>> d = {"bob":1, "gene":2}
>>> d
{'bob': 1, 'gene': 2}
// 查
>>> d["bob"]
1
// 增，同样dict值类型也可以不完全一样
>>> d["grace"] = "33"
>>> d
{'bob': 1, 'gene': 2, 'grace': '33'}
>>>
// 删
>>> d.pop("bob")
1
// 注意： 获取不存在的值会报错，所以使用中一般用get()来获取，如果对应key不存在，可以给一个默认值
>>> d["god"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'god'
>>> d.get("god")
>>> d.get("god", "where??")
'where??'
set:
// 定义
>>> s = set([1,2,3])
// 增
>>> s.add(4)
>>> s
set([1, 2, 3, 4])
// 删
>>> s.remove(1)
>>> s
set([2, 3, 4])
>>>
// 交
>>> s2 = set([1,2,4])
>>> s & s2
set([2, 4])
// 并
>>> s | s2
set([1, 2, 3, 4])
>>>
// 差
>>> s2 - s
set([1])
// python set很强大，使用起来非常爽，吐槽一下go，连个set都需要自己封一下😺
循环:
// list
a = [1, 2, "a"]
for x in a:
print x
// dict 获取key和value
for i, v in d.items():
print i, ':', v
// 通过key获取value
for key in d:
print d[key]
// while循环
a = 0
while a < 10:
a += 1
print a
条件判断：
age = 30
if age > 35:
print u"中年危机来了"
elif age > 30:
print u"该成家立业了"
else:
print u"还可以好好玩耍一哈"
函数：
// 定义, a与b是位置参数
def add(a, b):
return a + b
// add(1,2)
// 多返回值
def add(a, b):
return a + b, a-b
c, d = add(3, 2)
print c, d
>>>5 1
// 默认参数
def add(a, b, c=1):
return a + b + c
// 调用含默认参数的函数，如果不传默认参数的值，就取默认值
add(1, 2)
>>> 4
add(1,2,c=2)
>>> 5
// 可变参数, 可变参数可以省去我们显示的传入一个列表或是元组，传入的参数被封装成一个元组
def add(a, b, *args):
sum = 0
for arg in args: // args是一个元组
sum += arg
return a + b + sum
// 调用时可以不传入可变参数，如果传入一个列表或是元组，在列表变量前加*就可
add(1, 2)
add(1 ,2, 3, 4)
args = [2,3]
add(1,2, *args)
// 关键字参数，可变参数将参数封装成一个元组，而关键字参数将参数封装成一个dict，通过**定义个关键字参数
// 定义
def person(name, age, **kwargs):
print (name, age, "other:", kwargs)
person("xiaohong", 12, city="kunming", email="xx@qq.com")
>>>('xiaohong', 12, 'other:', {'city': 'kunming', 'email': 'xx@qq.com'})
// python2不支持下面两种？？
// 命名关键字参数, 关键字参数不知道传进来的key是什么，获取的时候需要判断；如果要固定死传进来的key命名，就用命名关键字参数
def person(name, age, *, city="city", email):
print (name, age, city, email)
// 如果函数前面有一个可变参数，那么在定义时，即可省略单个的特殊分隔符*
def person(name, age, *args, city, email):
print (name, age, city, email)
总结：
1 python 函数的入参和返参不会定义类型，想传什么就可以传什么，实力诠释了Python的放荡不羁，这就要特别注意在使用时，要注意入参的检查；在调用别人函数时，得去看函数的逻辑才能确定返回值类型，有点蛋疼，不像静态语言可以从函数定义就可以确定返回值类型；
2 函数的参数有5种，位置参数、默认参数、可变参数、关键字参数和命名关键字参数；
3 函数调用时，位置参数是必填的，其他是非必填的，命名关键字参数必须填入相同的关键字名；
切片：
//python中可以通过切片对list、tuple、string等进行截取一部分元素的操作，Python没有对string类定
//制很多其他的方法，不过通过切片可以很爽的完成各种对字符串的操作。
//Python切片操作的格式：[start_index:end_index:step]
/*
python中切片是**浅拷贝** ：
1.如果list中所有元素都是基本类型， 如：a = [1,2,3]，那么b=a[::]，b和a没有关联关系，相当于是新建了一个list b，然后把a的元素拷贝一份给b，修改b中的元素对a没有影响.
2.如果list中存在复合元素，非基本类型时，那么对于复合元素是浅拷贝的概念，是引用关系，如：a=[1,2,3,[1,2]], b=a[::], 如果对b中的前三个元素修改不会影响a，但是对b中的b[3]修改会同时反映到a上.
*/
// 具体场景，以list对象 a = [1,2,3,4,5,6,7]为例：
>>> b = a[::]
[1, 2, 3, 4, 5, 6]
// 步长为2
>>> a[::2]
[1, 3, 5]
// 从倒数第二个数开始
>>> a[-2::]
[5, 6]
// 如果元素是可变对象，得到的切片c,对可变对象的修改会反应到a上
>>> a = [1,2,3,4,5,6]
>>> b = [a, 7]
>>> c = b[::]
>>> c[0][0]=8
>>> a
[8, 2, 3, 4, 5, 6]
列表生产式：
// 列表生产式是用一行代码快速生成一个列表，结果得到是一个列表
>>> a = [x*x for x in range(0,10)]
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
// 支持if else运算
>>> a = [ x for x in range(0,10) if x >5]
>>> a
// if在后面时，不可以加else,因为此时是过滤元素，加else不合理
>>> a = [ x for x in range(0,10) if x >5 else 0]
File "<stdin>", line 1
a = [ x for x in range(0,10) if x >5 else 0]
^
SyntaxError: invalid syntax
// if在前面时，必须加else，此时是if/else是一个完整的表达式
>>> a = [ x if x > 5 else 0 for x in range(0,10)]
>>> a
[0, 0, 0, 0, 0, 0, 6, 7, 8, 9]
>>>
// 支持双层循环，全排列运算
>>> a = [ x+y for x in range(0,2) for y in range (0,2)]
>>> a
[0, 1, 1, 2]
列表生成器：
// 列表生成式得到的是一个列表，而列表生成器得到的是一个方法，调用这个方法，可以迭代得到元
// 素，用（）包裹一个列表生成式，就简单的得到一个生成器，可用for循环迭代
a = (x for x in range(0,5))
>>> for x in a:
... print x
0
1
2
3
4
可迭代对象和迭代器
// 可直接用于for的对象成为可迭代对象，例如：tuple list set dict str等, 可以用isintance()判断
// 生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
网友评论