python的sorted函数对字典按key排序和按value排序
1.sorted函数按key值对字典排序
先来基本介绍一下sorted函数，sorted(iterable,key,reverse)，sorted一共有iterable,key,reverse这三个参数。
其中iterable表示可以迭代的对象，例如可以是 dict.items()、dict.keys()等，key是一个函数，用来选取参与比较的元素，reverse则是用来指定排序是倒序还是顺 序，reverse=true则是倒序，reverse=false时则是顺序，默认时reverse=false。
要按key值对字典排序，则可以使用如下语句：
直接使用sorted(d.keys())就能按key值对字典排序，这里是按照顺序对key值排序的，如果想按照倒序排序的话，则只要将reverse置为true即可。
2.sorted函数按value值对字典排序
要对字典的value排序则需要用到key参数，在这里主要提供一种使用lambda表达式的方法，如下：
这里的d.items()实际上是将d转换为可迭代对象，迭代对象的元素为 （‘lilee’,25）、（‘wangyan’,21）、（‘liqun’,32）、（‘lidaming’,19），items()方法将字典的元素 转化为了元组，而这里key参数对应的lambda表达式的意思则是选取元组中的第二个元素作为比较参数（如果写作key=lambda item:item[0]的话则是选取第一个元素作为比较对象，也就是key值作为比较对象。lambda x:y中x表示输出参数，y表示lambda 函数的返回值），所以采用这种方法可以对字典的value进行排序。注意排序后的返回值是一个list，而原字典中的名值对被转换为了list中的元组。
默认sorted是对dict的key排序的，如果要根据dict的value排序就需要指定key参数了
my_dict = {"a":"2", "c":"5", "b":"1"}
result = sorted(my_dict)
print result
#默认对dict排序，不指定key参数,会默认对dict的key值进行比较排序
#result输出: ['a', 'b', 'c']
result2 = sorted(my_dict, key=lambda x:my_dict[x])
print result2
#指定key参数，根据dict的value排序
#result2输出:['b', 'a', 'c']
sorted()的reverse参数接受False 或者True 表示是否逆序
sorted()还有的参数例如cmp参数这里就不做多介绍了。
python 中将大列表拆分成小列表
将大列表拆分为小列表
>>> a = [1,2,3,4,5,6,7,8,9,0]
>>> n = 3
>>> c= [a[i:i+n] for i in range(0, len(a), n)]
二、将大列表套小列表转化为一个列表
>>> a [[1], [2], [3]] >>> b = [] >>> [b.extend(li) for li in a] [None, None, None] >>> b [1, 2, 3]
Python 中两个字典（dict）合并
dict1={1:[1,11,111],2:[2,22,222]}
dict2={3:[3,33,333],4:[4,44,444]}
合并两个字典得到类似
{1:[1,11,111],2:[2,22,222],3:[3,33,333],4:[4,44,444]}
方法1：
dictMerged1=dict(dict1.items()+dict2.items())
方法2：
dictMerged2=dict(dict1, **dict2)
方法2等同于：
dictMerged=dict1.copy()
dictMerged.update(dict2)
或者
dictMerged=dict(dict1)
dictMerged.update(dict2)
方法2比方法1速度快很多，用timeit测试如下
$ python -m timeit -s 'dict1=dict2=dict((i,i) for i in range(100))' 'dictMerged1=dict(dict1.items()+dict2.items())'
10000 loops, best of 3: 20.7 usec per loop
$ python -m timeit -s 'dict1=dict2=dict((i,i) for i in range(100))' 'dictMerged2=dict(dict1,**dict2)'
100000 loops, best of 3: 6.94 usec per loop
$ python -m timeit -s 'dict1=dict2=dict((i,i) for i in range(100))' 'dictMerged3=dict(dict1)' 'dictMerged3.update(dict2)'
100000 loops, best of 3: 7.09 usec per loop
$ python -m timeit -s 'dict1=dict2=dict((i,i) for i in range(100))' 'dictMerged4=dict1.copy()' 'dictMerged4.update(dict2)'
100000 loops, best of 3: 6.73 usec per loop
python如何将list中的字符转为数字
a=['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
转化为：a=[0, 1 ,2, 3, 4, 5, 6, 7, 8, 9]
代码如下：
list_to_float = list(map(lambda x:float(x), a)) print list_to_float
另一种写法：数字转换为字符
label =list((1,2,3,4,5,6,7,8,9,"10")) label_A =[str(i) for i in label] print(label_A)
（对于二维数组，需要加个循环,变成一维数组）
#coding=utf-8 #问题2：（对于二维数组，需要加个循环,变成一维数组） a=[['0', '1', '2'], ['3', '4', '5'], ['6', '7', '8']] #转化为：list=[[0, 1 ,2], [3, 4, 5], [6, 7, 8]] #代码如下： list_to_float = [] for each in a: each_line=list(map(lambda x: float(x), each)) list_to_float.append(each_line) print list_to_float
python字符串与列表的相互转换
学习内容：
1.字符串转列表
2.列表转字符串
1. 字符串转列表
str1 = "hi hello world"
print(str1.split(" "))
输出：
['hi', 'hello', 'world']
2. 列表转字符串
l = ["hi","hello","world"]
print(" ".join(l))
输出：
hi hello world
Python判断字符串是否为字母或者数字
严格解析：有除了数字或者字母外的符号（空格，分号,etc.）都会False
isalnum()必须是数字和字母的混合
isalpha()不区分大小写
str_1 = "123" str_2 = "Abc" str_3 = "123Abc" #用isdigit函数判断是否数字 print(str_1.isdigit()) Ture print(str_2.isdigit()) False print(str_3.isdigit()) False #用isalpha判断是否字母 print(str_1.isalpha()) False print(str_2.isalpha()) Ture print(str_3.isalpha()) False #isalnum判断是否数字和字母的组合 print(str_1.isalnum()) Ture print(str_2.isalnum()) Ture print(str_1.isalnum()) Ture
注意：如果字符串中含有除了字母或者数字之外的字符，比如空格，也会返回False
python 字符串补全填充固定长度（补0）的三种方法
''' 原字符串左侧对齐， 右侧补零: ''' str.ljust(width,'0') input: '789'.ljust(32,'0') output: '78900000000000000000000000000000' ''' 原字符串右侧对齐， 左侧补零: 方法一： ''' str.rjust(width,'0') input: '798'.rjust(32,'0') output: '00000000000000000000000000000798' ''' 方法二： ''' str.zfill(width) input: '123'.zfill(32) output:'00000000000000000000000000000123' ''' 方法三： ''' '%07d' % n input: '%032d' % 89 output:'00000000000000000000000000000089'
Python collections
collections是Python内建的一个集合模块，提供了许多有用的集合类。
1、namedtuple
namedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y']) # namedtuple是一个函数。这里创建了一个Point类，并为其定义了两个属性
>>> p = Point(1, 2) # 创建实例p
>>> p.x
1
2、deque
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈
>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])
deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。
3、defaultdict
使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict
>>> from collections import defaultdict
# defalutdict是个类，这里相当于给类传了一个匿名函数当方法。想想__getattr__
# dd指向这个类
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'
4、OrderedDict
使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。如果要保持Key的顺序，可以用OrderedDict
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key的排序，是按照插入的顺序
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
4.1、OrderedDict实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key
from collections import OrderedDict
class LastUpdatedOrderedDict(OrderedDict): # 创建类
def __init__(self, capacity):
super(LastUpdatedOrderedDict, self).__init__() # 调用父类的方法初始化参数
self._capacity = capacity
def __setitem__(self, key, value):
containsKey = 1 if key in self else 0 # 判断key是否存在
if len(self) - containsKey >= self._capacity: #超出容量怎么办
# popitem()方法作用是：随机返回并删除字典中的一对键和值（项）
# popitem()的随机删除，是建立在dict的无序基础上的
last = self.popitem(last=False) #last=False：先进先出。 last=True：先进后出
print('remove:', last)
if containsKey: #重新给key设value
del self[key]
print('set:', (key, value))
else: # 添加键值对
print('add:', (key, value))
OrderedDict.__setitem__(self, key, value) #调用方法
5、Counter
Counter是一个简单的计数器，例如，统计字符出现的个数
>>> from collections import Counter
>>> c = Counter() # Counter实际上也是dict的一个子类
>>> for ch in 'programming':
... c[ch] = c[ch] + 1
...
>>> c
Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})
python3 去除字符串中的数字
python3: from string import digits s = 'abc123def456ghi789zero0' remove_digits = str.maketrans('', '', digits) res = s.translate(remove_digits) # 'abcdefghizero' 或者： filter(lambda x: x.isalpha(), "a1a2a3s3d4f5fg6h")
还可以： for i in range(10): a.replace(str(i),'') python2: from string import digits s = 'abc123def456ghi789zero0' res = s.translate(None, digits) # 'abcdefghizero'
用Python去掉字符串的空格
如果用Python去除字符串两边的空格。 我们先创建一个左右都有N个空格的字符串变量，看代码： >>> s = “ iplaypython ” >>> 去除字符串空格，在Python里面有它的内置方法，不需要我们自己去造轮子了。 lstrip 这个字符串方法，会删除字符串s开始位置前的空格。 >>> s.lstrip() 'iplaypython ' rstrip 这个内置方法可以删除字符串末尾的所有空格，看下面演示代码： >>> s.rstrip() ' iplaypython' strip 有的时候我们读取文件中的内容，每行2边都有空格，能不能一次性全部去掉呢，字符符有一个内置的strip()方法可以做到。 >>> s = “ iplaypython ” >>> s.strip() 'iplaypython' 大家可以用 dir(str) 这个方法，获得 str字符串的所有方法名单。
In[2]: a=' ddd dfe dfd efre ddd ' In[3]: a Out[3]: ' ddd dfe dfd efre ddd ' In[4]: a.strip() Out[4]: 'ddd dfe dfd efre ddd' In[5]: a.lstrip() Out[5]: 'ddd dfe dfd efre ddd ' In[6]: a.rstrip() Out[6]: ' ddd dfe dfd efre ddd' #去掉字符串中的空格 In[7]: a.replace(' ','') Out[7]: 'ddddfedfdefreddd' In[8]: a.split() Out[8]: ['ddd', 'dfe', 'dfd', 'efre', 'ddd']
python中的单引号，双引号和三双引号的区别
1.单引号和双引号没有区别。都可以用就是为了方便，减少写太多的转义字符。
比如：
str='Let\'s go!' str="Let's go!"
两种等价，但是第二种写法显然更优雅。
2.三个双引号用来输入多行文本，也就是说在三引号之间输入的内容将被原样保留，之中的单号和双引号不用转义，其中的不可见字符比如\n和\t都会被保留，这样的好处是你可以替换一些多行的文本。
Python的sort函数和sorted、lambda和cmp
1、sort和sorted
我们需要对List进行排序，Python提供了两个方法
方法1.用List的成员函数sort进行排序
方法2.用built-in函数sorted进行排序（从2.4开始）
iterable：是可迭代类型;
cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的一项;
key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;
reverse：排序规则. reverse = True 或者 reverse = False，有默认值。
返回值：是一个经过排序的可迭代类型，与iterable一样。
注；一般来说，cmp和key可以使用lambda表达式。
sort()与sorted()的不同在于，sort是在原位重新排列列表，而sorted()是产生一个新的列表。
Sorting basic:
[1, 2, 3, 4, 5]
>>> L = [5, 2, 3, 1, 4]
>>> L.sort()
>>> print L
[1, 2, 3, 4, 5]
Sorting cmp:
>>>L = [('b',2),('a',1),('c',3),('d',4)]>>>print sorted(L,cmp=lambda x,y:cmp(x[1],y[1])) #x，y分别代表第一项和第二项（按照每项的第二个元素排序）。
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
Sorting keys:
>>>L = [('b',2),('a',1),('c',3),('d',4)]>>>print sorted(L, key=lambda x:x[1]))
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
Sorting reverse:
[5, 4, 3, 2, 1]
>>> print sorted([5, 2, 3, 1, 4], reverse=False)
[1, 2, 3, 4, 5]
注：效率key>cmp(key比cmp快)
在Sorting Keys中：我们看到，此时排序过的L是仅仅按照第二个关键字来排的，如果我们想用第二个关键字
排过序后再用第一个关键字进行排序呢?
>>> L = [('d',2),('a',4),('b',3),('c',2)]
>>> print sorted(L, key=lambda x:(x[1],x[0]))
>>>[('c', 2), ('d', 2), ('b', 3), ('a', 4)]
现有列表ll=[(1,2),(4,5),(8,9),(1,1),(4,3),(8,20)]，要实现排序，排序规则为：按元组第一个元素降序，如果元祖第一个元素相同按元祖第二个元祖升序。
import functools def tcmp(x,y): #只能返回[-1,0,1]分别对应逆序，不变，升序 if x[0]!=y[0]: #因为排序默认为升序排序，所以在x[0]>y[0]情况下，要想让x[0]在y[0]前面 #也就是逆序，所以要返回-1 return -1 if x[0]>y[0] else 1 elif x[1]!=y[1]: return 1 if x[1]>y[1] else -1 else: #按原来顺序 return 0 if __name__=="__main__": ll=[(1,2),(4,5),(8,9),(1,1),(4,3),(8,20)] ll.sort(key=functools.cmp_to_key(tcmp))#python3没有cmp关键字，所以必须把cmp函数转换为key print(ll)
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
如下例子：
定义了一个lambda表达式，求三个数的和。
再看一个例子：
用lambda表达式求n的阶乘。
这里定义了一个action函数，返回了一个lambda表达式。其中lambda表达式获取到了上层def作用域的变量名x的值。
a是action函数的返回值，a(22)，即是调用了action返回的lambda表达式。
这里也可以把def直接写成lambda形式。如下
3 扩展用法：Key Function
从Python2.4开始，list.sort() 和 sorted() 都增加了一个 ‘key’ 参数用来在进行比较之前指定每个列表元素上要调用的函数。
例1： 不区分大小写的字符串比较排序：
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
key应该是一个函数，其接收一个参数，并且返回一个用于排序依据的key。其执行效率很高，因为对于输入记录key function能够准确的被调用。
例2 :对于复杂的对象，使用对象的下标作为key：
从python2.4开始，list.sort()和sorted()函数增加了key参数来指定一个函数，此函数将在每个元素比较前被调用
key参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较。这个技术是快速的因为key指定的函数将准确地对每个元素调用。
>>> student_tuples = [
... ('john', 'A', 15),
... ('jane', 'B', 12),
... ('dave', 'B', 10),
... ]
>>> sorted(student_tuples, key=lambda student: student[2]) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
例3 使用对象的属性进行操作：
>>> class Student:
... def __init__(self, name, grade, age):
... self.name = name
... self.grade = grade
... self.age = age
... def __repr__(self):
... return repr((self.name, self.grade, self.age))
>>>
>>> student_objects = [
... Student('john', 'A', 15),
... Student('jane', 'B', 12),
... Student('dave', 'B', 10),
... ]
>>> sorted(student_objects, key=lambda student: student.age) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
当列表里面每一个元素不止一个元素（比如：列表里面，元素为元祖类型），我们除了想对第一个关键字排序之外，还想在第一次的基础上面根据第二个关键字进行排序：
>>> list2 = [('d', 3), ('a', 5), ('d', 1), ('c', 2), ('d', 2)]
>>> list2
[('d', 3), ('a', 5), ('d', 1), ('c', 2), ('d', 2)]
>>> list2.sort()
>>> list2
[('a', 5), ('c', 2), ('d', 1), ('d', 2), ('d', 3)]
>>> list3 = [('d', 3), ('a', 5), ('d', 1), ('c', 2), ('d', 2)]
>>> sorted(list3, key = lambda x:(x[0],x[1]))
[('a', 5), ('c', 2), ('d', 1), ('d', 2), ('d', 3)]
4 Operator Module Functions
这个操作模块有：
operator.itemgetter() ----- 通过下标operator.attrgetter() ----- 通过参数operator.methodcaller() -----python 2.5 被引入，下文详细介绍
使用这几个函数，对于上面 Key Function 的例子处理起来将会更加的简便和快速
先一块介绍 operator.itemgetter() 和 operator.attrgetter() 这俩个，会更加容易理解：
例如：
>>> from operator import itemgetter, attrgetter
>>>
>>> sorted(student_tuples, key=itemgetter(2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>>
>>> sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
这个操作模块也允许多层次的进行排序，例如可以先排序 “成绩grand” 再排序 “年龄age”
例如：
>>> sorted(student_tuples, key=itemgetter(1,2))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
>>>
>>> sorted(student_objects, key=attrgetter('grade', 'age'))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
现在回过头来发现，上面在前几天遇到的问题，可以用这个operator.itemgetter进行解决：
>>> list = [('d',3),('a',5),('d',1),('c',2),('d',2)]
>>> from operator import itemgetter
>>> sorted(list, key=itemgetter(0,1))
[('a', 5), ('c', 2), ('d', 1), ('d', 2), ('d', 3)]
但是还是推荐 1.key function 中的方法，因为为了这一个排序而引入一个库文件，相对来说得不偿失。
下面介绍operator.methodcaller() 函数：
这个函数是对某个对象的使用固定参数进行排序，例如：str.count() 函数可以计算每个字符串对象中含有某个参数的个数，那运用这个函数我就可以通过 str.count() 计算出某个字符的个数从而来确定排序的优先级：
>>> from operator import methodcaller
>>> messages = ['critical!!!', 'hurry!', 'standby', 'immediate!!']
>>> sorted(messages, key=methodcaller('count', '!'))
['standby', 'hurry!', 'immediate!!', 'critical!!!']
python字符串连接的N种方式总结
利用字符串的函数 join 。这个函数接受一个列表，然后用字符串依次连接列表中每一个元素： var_list = ['tom', 'david', 'john'] a = '###' a.join(var_list) = 'tom###david###john' 其实，python 中还有一种字符串连接方式，不过用的不多，就是字符串乘法，如： a = 'abc' a * 3 = 'abcabcabc'
python 获取list特定元素下标
在平时开发过程中，经常遇到需要在数据中获取特定的元素的信息，如到达目的地最近的车站，橱窗里面最贵的物品等等。怎么办？看下面
方法一： 利用数组自身的特性 a.index(target), 其中a是你的目标list，target是你需要的下标对应的值
a=[72, 56, 76, 84, 80, 88]
print(a.index(76))
output:
2
但是，如果a中有多个76呢？
我们发现，这种方法仅仅能获取都第一个匹配的value的下标（可以试试o_o）
所以，我们看看我们的第二种方案：
方法二： 利用enumerate函数。废话少说，看例子
哎哟，原来enumerate的输出类型是tuple！tuple！tuple！ 所以,我们可以如下
再看，如果a中有多个‘76’呢？
可见，list的index()方法是在list中找到第一个匹配的值。
而enumerate是将list（当然，也包含其它类型）中的元素元组化，然后我们利用循环方法获取相应的匹配的结果。所以方案二对于重复的数值能够一个不漏的get出来。
python for循环巧妙运用（迭代、列表生成式）
python提供了更简便的方法处理这个需求
>>> [x*x for x in range(1,11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2.添加判断条件
只取列表中的偶数
>>> [x*x for x in range(1,11) if x%2==0] [4, 16, 36, 64, 100]
3.多个for同时判断
>>> [m+n for m in 'ABC' for n in'abc'] ['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']
4.获取dict中的value
一般for操作只能获取dict中的key而无法获取到value,可以利用items获取到values
>>> d={'a': 'A', 'b': 'B', 'c': 'C'}
>>> [k + '=' + v for k,v in d.items()]
['c=C', 'a=A', 'b=B']
注意：由于dict是单个key-value所以在for之前不能直接使用k,v for k,v这样代表k,v是多个key而不是指key-value,所以只能进行计算，但是如果计算的话又必须保证key和value是相同的数据类型否则无法进行+操作
针对key和value是不同的数据类型可以使用普通的for循环，使用print输出
#!/usr/bin/env python3
#-*- coding:utf-8 -*-
d={'a': 1, 'b': 2,'c': 3}
for k,v in d.items():
print(k,'=',v)
5.list中所有的字符串变成小写
>>> L = ['Hello', 'World', 'IBM', 'Apple'] >>> [s.lower() for s in L] ['hello', 'world', 'ibm', 'apple']
两个list合并成一个dict的方法
使用内置函数的话，zip的方法：
>>> l1=[1,2,3,4,5,6] >>> l2=[4,5,6,7,8,9] >>> print(dict(zip(l1,l2))) {1: 4, 2: 5, 3: 6, 4: 7, 5: 8, 6: 9}
那么还有一种情况，当两个list的长度不一样，如果要组成dict的话，怎么办呢？按逻辑处理是这样的：
但是实际上，我们直接执行这个就可以：
>>> ls1=[1,2,3,4,5,6,7] >>> ls2=[4,5,89,1] >>> print(dict(zip(ls1,ls2))) {1: 4, 2: 5, 3: 89, 4: 1}
它会自动的匹配！自动的省去多余的部分！
Python 之 向上取整、向下取整以及四舍五入函数
import math f = 11.2 print math.ceil(f) #向上取整 print math.floor(f) #向下取整 print round(f) #四舍五入 #这三个函数的返回结果都是浮点型
python字符串相关操作
字符串搜索相关
搜索指定字符串，没有返回-1：str.find('t')
指定起始位置搜索：str.find('t',start)
指定起始及结束位置搜索：str.find('t',start,end)
从右边开始查找：str.rfind('t')
搜索到多少个指定字符串：str.count('t')
上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1
字符串判断相关
是否以start开头：str.startswith('start')
是否以end结尾：str.endswith('end')
是否全为字母或数字：str.isalnum()
是否全字母：str.isalpha()
是否全数字：str.isdigit()
是否全小写：str.islower()
是否全大写：str.isupper()
字母处理
全部大写：str.upper()
全部小写：str.lower()
大小写互换：str.swapcase()
首字母大写，其余小写：str.capitalize()
首字母大写：str.title()
1.对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'
2.在Python中，采用的格式化方式和C语言是一致的，用%实现，举例如下：
>>> 'Hello, %s' % 'world' 'Hello, world' >>> 'Hi, %s, you have $%d.' % ('Michael', 1000000) 'Hi, Michael, you have $1000000.' 你可能猜到了，%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
常见的占位符有：
其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
>>> '%2d-%02d' % (3, 1) ' 3-01' >>> '%.2f' % 3.1415926 '3.14' 如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：
>>> 'Age: %s. Gender: %s' % (25, True) 'Age: 25. Gender: True' 有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：
>>> 'growth rate: %d %%' % 7 'growth rate: 7 %'python 除法保留两位小数点
#coding=utf-8 a = 1 b = 3 print(a/b) #0 #方法一： print(round(float(a)/b,2)) #0.33 #方法二： print(format(float(a)/float(b),'.2f')) #0.33
python list的深拷贝与浅拷贝-以及初始化空白list的方法(2)
其实python对于深拷贝与浅拷贝的处理方式依然是很灵活的，甚至有一个专门的工具包copy来做个事情
来看以下这组list的拷贝方法：
已知lista是一个已经定义好了的list
listb=lista
注意，这个并不是一个copy的过程，这里lista与listb完全等同
以下提供一些copy方法，但注意是深copy还是浅copy:
定义:lista=[2,[4,5]]
listb=lista[:]
listb=list(lista)
listb=[i for i in lista]
import copy;listb=copy.copy(lista)
import copy;listb=copy.deepcopy(lista)
拷贝完毕后，再进行以下操作：
listb[1].append(9)
print lista,listb
五种拷贝方式之后的结果如下：
[2,[4,5,9]],[2,[4,5,9]]
[2,[4,5,9]],[2,[4,5,9]]
[2,[4,5,9]],[2,[4,5,9]]
[2,[4,5,9]],[2,[4,5,9]]
[2,[4,5]],[2,[4,5,9]]
# import copy # a = {"name":"ljt","age":10,"c":{"name":"zbj"}} # b = copy.copy(a) # print id(a),id(b) # print b.pop("c") # # print a # print b # import copy # a = [1,23,4,[22,1,4]] # b = copy.copy(a) # print id(a),id(b) # del a[1] # print a # print b
将字典可以转换为列表
d = {'abc':123,'tgr':983,'hyt':345}
print d.items()
d = {'abc':[123,64,45],'tgr':983,'hyt':[345,34]}
print d.items()
exit(0)
字典的值的列表
d = {} d['wer'] = [4,5,6,7,8,1] d['df4'] = [65,43,890,678,90] d['ert'] = [78,34,32,56,89] print d.values()
每隔2个步长取列表中的数字
a = [1,2,3,4,5,6,7,8,9] print a for index in range(0,len(a),2): print a[index]
构造json串
# import json # info = '{"a":1,"b":2}'#构造json格式 # print json.loads(info)
python中unicode 和 str相互转化
python中的str对象其实就是"8-bit string" ，字节字符串，本质上类似java中的byte[]。
而python中的unicode对象应该才是等同于java中的String对象，或本质上是java的char[]。
str: s = "你好"
unicode: u = u"你好“
unicode转化为str，采用encode 编码：
str = u.encode('gbk')
str转化为unicode ，采用decode 解码：
unicode = s.decode('gbk')
python从字符串中提取数字_filter
my_str = '123and456' number = filter(str.isdigit, my_str )
# number = 123456
Python map() 函数
描述
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法
map() 函数语法：
map(function, iterable, ...)
参数
- function -- 函数
- iterable -- 一个或多个序列
返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器。
names = ["KSssA","ashfK"]#将列表中的首字母大写，其余小写
def low_to_upper(name):
return str(name[0]).upper() + str(name[1:]).lower()
def low_to_upper_list(names):
return list(map(low_to_upper,names))
if __name__ == "__main__":
print low_to_upper_list(names)
Python字节bytes
bytes
bytes对象只负责以二进制字节序列的形式记录所需记录的对象，至于该对象到底表示什么（比如到底是什么字符）则由相应的编码格式解码所决定
bytes是Python 3中特有的，Python 2 里不区分bytes和str。
python3中：
str 使用encode方法转化为 bytes
bytes通过decode转化为str
In [9]: str1='人生苦短，我用Python!'
In [10]: type(str1)
Out[10]: str
In [11]: b=str1.encode()
In [12]: b
Out[12]: b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\
xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!'
In [13]: type(str1.encode())
Out[13]: bytes
bytes转换成str：
In [22]: b
Out[22]: b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\
xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!'
In [23]: type(b)
Out[23]: bytes
In [24]: b.decode()
Out[24]: '人生苦短，我用Python!'
In [25]: type(b.decode())
Out[25]: str
在Python 2中由于不区分str和bytes所以可以直接通过encode()和decode()方法进行编码解码。
而在Python 3中把两者给分开了这个在使用中需要注意。实际应用中在互联网上是通过二进制进行传输，所以就需要将str转换成bytes进行传输，而在接收中通过decode()解码成我们需要的编码进行处理数据这样不管对方是什么编码而本地是我们使用的编码这样就不会乱码。
bytearray
bytearray和bytes不一样的地方在于，bytearray是可变的。
In [26]: str1
Out[26]: '人生苦短，我用Python!'
In [28]: b1=bytearray(str1.encode())
In [29]: b1
Out[29]: bytearray(b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!')
In [30]: b1.decode()
Out[30]: '人生苦短，我用Python!'
In [31]: b1[:6]=bytearray('生命'.encode())
In [32]: b1
Out[32]: bytearray(b'\xe7\x94\x9f\xe5\x91\xbd\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!')
In [33]: b1.decode()
Out[33]: '生命苦短，我用Python!'2、json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？
答： 可以处理的数据类型是 str、int、list、tuple、dict、bool、None, 因为 datetime 类不支持 json 序列化，所以我们对它进行拓展。
- # 自定义时间序列化
- import json
- from datetime import datetime, date
- # JSONEncoder 不知道怎么去把这个数据转换成 json 字符串的时候
- # 它就会去调 default()函数，所以都是重写这个函数来处理它本身不支持的数据类型，
- # default()函数默#认是直接抛异常的。
#coding=utf-8
import json
from datetime import datetime, date
# JSONEncoder 不知道怎么去把这个数据转换成 json 字符串的时候
# 它就会去调 default()函数，所以都是重写这个函数来处理它本身不支持的数据类型，
# default()函数默#认是直接抛异常的。
class DateToJson(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(obj, date):
return obj.strftime('%Y-%m-%d')
else:
return json.JSONEncoder.default(self, obj)
d = {'name': 'cxa', 'data': datetime.now()}
print(json.dumps(d, cls=DateToJson))
3、json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？
答：可以通过 json.dumps 的 ensure_ascii 参数解决，代码示例如下：
- import json
- a=json.dumps({"name":"张三"},ensure_ascii=False)
- print(a)
1、将"hello world"转换为首字母大写"Hello World"
方案一：
- "hello world".title()
非常简单一句话搞定。
方案二：
如果只是第一个单词首字母大小的话，只使用capitalize 即可，但是这里是两个单词，所以首先需要切分字符串为单词数组：
- arr = "hello world".split(" ")
2、如何检测字符串中只含有数字?
答：可以通过 isdigit 方法，例子如下
- s1 = "12223".isdigit()
- print(s1)
- s2 = "12223a".isdigit()
- print(s2)
结果如下：
- #True
- #False
3、将字符串"ilovechina"进行反转
- s1 = "ilovechina"[：：-1]
- print(s1)
4、Python 中的字符串格式化方式你知道哪些？
答：%s，format，fstring(Python3.6 开始才支持，现在推荐的写法)
5、获取字符串”123456“最后的两个字符。
答：切片使用的考察，最后两个即开始索引是 -2，代码如下
- a = "123456"
- print(a[-2：：])
6、一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串，应如何操作？
- a= "S".encode("gbk").decode("utf-8",'ignore')
- print(a)
7、怎样将字符串转换为小写。
答：使用字符串的 lower() 方法。
8、单引号、双引号、三引号的区别？
单独使用单引号和双引号没什么区别，但是如果引号里面还需要使用引号的时候，就需要这两个配合使用了，然后说三引号，同样的三引号也分为三单引号和三双引号，两个都可以声明长的字符串时候使用，如果使用 docstring 就需要使用三双引号。
写出一段python 代码实现一个删除一个list 里面重复元素。
答案：
list_element = ['a','c,','z','x','a'] #此列表元素有重复
delete_element = list( set(list_element)) #利用集合的唯一性删除重复元素
print("原始列表为：",list_element)
print("修改后的列表为：",delete_element)
结果：
原始列表为： ['a', 'c,', 'z', 'x', 'a'] 修改后的列表为： ['c,', 'x', 'z', 'a'] Process finished with exit code 0
但是这样做有缺点，就是去重后，元素的排序改变了，想保持原来的排序，我们需要用下面的方法：
list_element = ['a','c,','z','x','a'] #此列表元素有重复 delete_element = list( set(list_element)) #利用集合的唯一性删除重复元素 delete_element.sort(key = list_element.index) #对修改后的列表进行排序
sorted(delete_element,key=lambda x:list_element.index(x))#或者用这种方式,上面是简写
print("原始列表为：",list_element) print("修改后的列表为：",delete_element)
结果：
原始列表为： ['a', 'c,', 'z', 'x', 'a'] 修改后的列表为： ['a', 'c,', 'z', 'x'] Process finished with exit code 0
delete_element