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