字符串
创建
s1 = 'lenovo'
s2 = "XC "
拼接
print('hello' + 'lenovo')
不可以用 字符串和 一个非字符串类型的对象相加
- 复制
print('*' * 20)
print('lenovo 666' * 20)
字符串 和 0 或者 负数相乘，会得到一个空字符串
获取字符串的长度，包含空格和换行符
n = len(s1)
print(n)
利用字符串对象的方法
split 分割
默认使用 空格或者 Tab 间做为分隔符
> url = 'www.baidu.com 百度官网'
> url.split()
['www.baidu.com', '百度官网']
可以指定分隔符
> ip = '192.168.1.100'
> ip.split('.')
['192', '168', '1', '100']
rsplit 从右向左分割
找到第一个分隔符，就结束。
> ip.rsplit('.', 1)
['192.168.1', '100']
>
replace 替换
>url = 'www.baidu.com'
>url.replace('.', '_')
www-baidu-com
strip 移除字符串两端的空白字符
> s = ' shark '
> s
' shark '
>>> s.strip()
'shark'
s="symbol=BCHBTC;baseCoin=BCH;quoteCoin=BTC;"
s_list = s.split(';')
# print(s_list)
# ['symbol=BCHBTC', 'baseCoin=BCH', 'quoteCoin=BTC', '']
startswith 判断字符串以什么为开头
s = 'hello world'
if s.startswith('h'):
print(s)
endswith 判断字符串以什么为结尾
s = 'hello world'
if s.endswith('d'):
print(s)
index 获取一个元素在字符串中的索引号
s = 'hello world'
idx = s.index('l')
列表
创建列表
> li = []
> l2 = [1,2,'biadu']
list 从其他类型转换
list('hello')
['h','e','l','l','o']
嵌套的列表
列表中可包含 python 中任何类型的元素(对象)，当然也可以包括一个或多个列表
li = [['one', 'two', 'three'], [1, 2, 3]]
列表的基本操作
取值
li_f = [ 'insert', 'append','extend', 'remove', 'pop', 'sort', 'sorted']
li_f[0] # insert
嵌套的列表
l2 = [['one', 'two', 'three'], [1, 2, 3]]
l2[0][1]
two
切片
同字符串的切片一样
li_f = [ 'insert', 'append','extend', 'remove', 'pop', 'sort', 'sorted']
# 获取全部元素
li_f[:]
# 反转
li_f[::-1]
列表操作
len()
方法是一个内置函数，可以统计序列类型的数据结构的长度。
li = [5, 4, 3, 2, 1, 0]
n = len(li)
print(n)
in
判断元素是否存在于列表中
li = [5, 4, 3, 2, 1, 0]
if 5 in li:
print('存在')
append()
向列表的最后位置，添加一个元素，只接收一个参数。
li.append('a')
print(li)
insert()
向原列表的指定位置插入一个元素，接收两个参数，
第一个是索引号，第二个是要插入的元素。
li.insert(0, 'b')
print(li)
extend()
可以把一个序列类型中的每个元素追加到原列表中，接收的参数是一个序列类型的数据（字符串，列表）。
l2 = ['qf','yangge']
li.extend(l2)
print(li)
remove()
移除列表中某个指定的元素，没有返回值，并且假如有多个相同值的元素存在，每次只会移除排在最前面的那个元素
obj.remove('a') 。
pop()
从原列表中删除一个元素，并且把这个元素返回。
接收零个或一个参数，参数是偏移量，int 类型。
# 删除列表中的最后一个元素
li.pop()
# 删除列表中第二个索引号对应的元素，并且返回这个元素，用变量名`n` 接收。
n = li.pop(2)
**''.join() **
把列表中的元素拼接起来，返回的是字符串类型
l7 = ['a','b']
s = ''.join(l7)
print(s)
# 输出
'ab'
还可以以指定的字符进行拼接
l7 = ['a','b']
s = '-'.join(l7)
print(s)
# 输出
'a-b'
index()
返回指定元素的索引号。
idx = li.index(4)
print(idx)
字典
高效创建字典
空字典
In [7]: d1 = {}
In [8]: type(d1)
Out[8]: dict
字典中元素是无序的
In [1]: d2 = {'shark': '鲨鱼', 'qf': '千锋'}
In [2]: d2
Out[2]: {'qf': '千锋', 'shark': '鲨鱼'}
dict() 转换为字典
接收一个序列类型的参数，这个序列类型中的每个元素必须是成对儿出现的。
In [14]: d_tpl = [('a','1'),('b','2'),('c','3')]
In [15]: dict3 = dict(d_tpl)
In [17]: d_tpl2 = ['a1','b2','c3']
In [18]: dict4 = dict(d_tpl2)
In [21]: dict3 is dict4
Out[21]: False
In [22]: dict3 == dict4
Out[22]: True
zip() 并行迭代
zip() 函数可以对多个序列进行并行迭代
en =['a', 'b', 'c', 'd']
nums = ['1', '2', '3', '4']
for word, num in zip(en, nums):
print(word, num)
利用 zip() 函数可以对具有相同数量的元素的序列进行配对，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量。
In [36]: en = 'a','b','c',
In [37]: nums = '1' , '2', '3'
In [38]: zip(en, nums)
Out[38]:
In [39]: type(zip(en, nums))
Out[39]: zip
In [40]: list(zip(en, nums))
Out[40]: [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
In [41]: dict(zip(en, nums))
Out[41]: {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
获取 key 对应的 value
dict_obj = {'a': 1, 'b': 2}
dict_obj['a'] # key 必须存在，不存在，抛出异常
dict_obj.get('a') # 获取到 'a' 对应的值(value)
dict_obj.get('c') # key 不存在字典中，则返回 None
dict_obj.get('c', '5') # key 不存在，返回指定的 value
示例
info_dict = {"name": 'yangge', 'age': 18}
na = info_dict['name']
print(na)
naa = info_dict['dd']
age = info_dict.get('age')
print(age)
age2 = info_dict.get('asdf')
print(type(age2),age2)
age3 = info_dict.get('adaf', '')
print(type(age3),age3)
age4 = info_dict.get('adaf', 28)
print(type(age4),age4)
获取字典所有的 key
dict_obj.keys()
info_dict = {"name": 'yangge', 'age': 18}
d_keys = info_dict.keys()
print(d_keys)
print(list(d_keys))
获取字典所有的 value
dict_obj.values()
info_dict = {"name": 'yangge', 'age': 18}
d_vals = info_dict.values()
print(d_vals)
print(list(d_vals))
同时获取字典的 key 和 value
dict_obj.items()
info_dict = {"name": 'yangge', 'age': 18}
item = info_dict.items()
print(item)
print(list(item))
使用 update() 更新字典
把一个已经存在的字典中的键值对，添加到另一个字典中。
In [59]: d5
Out[59]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
In [60]: d6 = {'a': 2,'d': 2,'e': 5}
In [61]: d5.update(d6)
In [62]: d5
Out[62]: {'a': 2, 'b': 2, 'd': 2, 'e': 5, 'li': [1, 3, 5]}
注意： 更新时，相同的 key ，它的值会被新的值替代，这个特性同样适用与 = 号方式的更新.
成员判断
in
In [63]: 'a' in d5 # 默认就是判断 'a' 是否存在于字典中的 keys()
Out[63]: True
In [63]: 'a' in d5.keys()
Out[63]: True
In [75]: 'a' not in d5.keys()
Out[75]: False
pop()
从字典中删除指定 key 的键值对，并返回这个 key 对应的值
In [49]: d6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}
In [50]: li = d6.pop('li')
In [51]: print(li)
Out [51]: [1, 3, 5]
popitem()
删除字典中的键值对，并返回这个键和值
item = d6.popitem()
print(item)
print(d6)
"""
('li', [1, 3, 5])
{'b': 2, 'c': '3', 'd': 'new key'}
"""
用字典实现 switch … case 语句
Python 中没有 switch … case 语句，这个问题Python之父龟叔表示这个语法过去没有，现在没有，以后也不会有。因为Python简洁的语法完全可以用 if … elif 实现。如果有太多的分支判断，还可以使用字典来代替。
hile True:
arg = input(">>:")
if arg == '0':
print('zero')
elif arg == '1':
print('one')
elif arg == '2':
print("two")
else:
print("nothing")
python 建议使用下面的代码实现
data = {
"0": "zero",
"1": "one",
"2": "two",
}
while True:
arg = input(">>:")
v = data.get(arg, 'nothing')
print(v)
setdefault 处理缺失的键
dict_obj.setdefatult(‘key’, ‘value’)
- key 不存在，添加 key: value 到字典中,并且返回字典中的 value 对象，也就是说返回的 value 和刚添加到字典中的 value 是同一个对象 ；
- key 存在, 返回对应的 value，原字典不变
分类统计实例
data = [
("ip", "192.168.1.100"),
("ip", "192.168.1.200"),
("port", 22),
("user", "yangge"),
("user", "shark")
]
bad
groups = {}
for key, val in data:
# 判断 key 是否在于字典中
if key not in groups.keys():
# key 不存在字典中，把键值对添加到此字典中
# 此时，key 对应的值是一个列表类型，这个类别包含了循环的 val
groups[key] = [val]
else:
# key 存在字典中，则把 val 添加到 key 对应的值中
# 这值是一个列表。
groups[key].append(val)
good
groups = {}
for item in data:
li = d1.setdefault(item[0], [])
li.append(item[1])
print(d1)