python基礎知識點
阿新 • • 發佈:2018-03-06
死循環 ext 反轉 布爾型 for 移除 seek window ict python論壇:
1. python 腳本格式
前2行格式如下,第一行是表示用python執行,第二行是通用字符集,任何語言都能正常顯示。
1)#!/usr/bin/env python
2)#_*_coding:utf-8_*_ (貌似寫成#coding=utf-8也行)
其實上面的語句怎麽寫都行,只要符合coding[ := ]\s*([-\w.]+); 意思就是coding後面要緊緊的跟著冒號或者等號,之後可隨意多少個空格,然後接utf-8,coding=utf-8前後隨意加字符都行。
\w匹配的是能組成單詞的字符
\s表示空格
3)第三行最好用雙引號來寫一個腳本文檔,來對此腳本做解釋
"......."
4)多行註釋,三個雙引號開頭,三個雙引號結尾。
"""
......
......
"""
註意,第一行很多人會寫成#!/usr/bin/python,如果是系統默認有的python這樣寫是沒錯的,但是如果你升級了一個python,那麽這個新版的python可能就會安裝在usr/local/bin目錄下,如果加上env,就會直接使用 新版的python,因為新裝的python會自動寫在env中。
2017/8/11 15:03
一. 編程風格
1. 語法要求,縮進統一: 屬於同一代碼塊,也就是同一級別,相互之間沒有依存關系的語言縮進必須是一致的,不然就會報錯
註意,如果是在window下用notepad寫的代碼,用tab進行縮進時,需要在notepad中進行tab建和空格鍵的轉換設置,在首選項中可設置。
2. 變量由字母,下劃線,數字組成
標識符的第一個字符必須是字母表中的字符(大小寫都行)或者一個下劃線
標識符的其他部分可以由字符(大小寫)*,下劃線或數字(0-9)組成。
無效的標識符例子有2things; this is a man; my-name
3.python編譯過程--腳本解釋型語言
在運行腳本之後,得到結果之前
1)python先將腳本編譯成字節碼(pyc,pyo)
腳本中只要import 函數,就會生成pyc文件
2)python虛擬機解釋並運行字節碼文件
C語言--編譯型語言的內部機制
1)先將源代碼編譯成機器碼,生成可執行文件
2)運行可執行文件
4,動態語義--在賦值時確定數據類型
例如 a=5 b=string, 那麽用type(a)=int; type(b)=string
5. python之禪
進入python,輸入import this 會看到
2017/8/14/周一
1. python一切數據皆為對象
包含了一系列的數據和操作這些數據的方法的一個整體,就叫作對象。
一切變量都是對數據對象的引用
python內部的引用計數,sys.getrefcount
import sys
a=‘hello‘
sys.getrefcount(‘hello‘)
輸出為3---python中初始數為3
e=‘hello‘
sys.getrefcount(‘hello‘)
輸出為4
a=1
sys.getrefcount(‘hello‘)
輸出為3,說明引用被銷毀一次。
2.數據類型的組成
組成3部分。
身份 id方法來看一看他的唯一標示符,內存地址靠這個哦!
類型 type來看一看。
值 數據項。
某書裏的傲嬌結論:python裏一切都是指針,所以不用再考慮指針這個問題了!
3. 常用基本數據類型.
int 整型
boolean 布爾
a=True
b=False
註意:首字符必須大寫
string 字符串
list 列表
tuple 元祖
dict 字典
4.數據類型的可變和不可變,意思就是如果變量的值改變後,id值是否改變
不可變類型:int,string,tuple
例如a = 5,看一下id值;然後a = 6, 再看一下id值,2個值是不同的
可變類型: list,dict
例如a = [1,2,3]
a.append(4),此時a=[1,2,3,4];但是改變前後,a的id值是不變的
5.變量之賦值一切皆為引用,動態性與動態類型之為何不再動態
如果給一個變量賦值後,它的數據類型就確定了,不能再隨意改變;比如a="4",此時不能在進行a+1的運算,因為"4"和1不是一個數據類型,不能計算。如果想計算,需要先把字符串a轉變為整型,方法就是int(a)+1.
字符串認知與應用
認知1.字符串概念
認知2.ascii unicode utf8到底是啥
一.len
len:全寫是length,是計算容量的函數;例如a = "1234", len(a)=4
如果是中文字符,比如a = "哈", len(a)=3, 那麽怎麽顯示正確的數目呢
方法一:在中文字符前加u 例如:a = u"哈" ,len(a)值為1
方法二:a ="哈哈"
g = a.decode(‘utf-8‘)
print len(g)值為2
方法二也可以直接寫成 a = "哈哈".decode(‘utf-8‘)
其實最好是a.decode(‘utf-8‘)
註意:
就是在腳本中標明#coding=utf-8,len的值還是按ascii碼來計算
比如
#coding=utf-8
d = "中文"
print len(d)
執行python test.py的值為6
二.轉義符讓文本更好處理
要轉義的字符前面加個反斜杠
三.字符串前面跟著的小尾巴到底是什麽東西
例如:print r"\n" 表示不進行轉義,輸出為\n
四.訪問子字符串,序列來了。
成員有是有序排列的,可以通過下標偏移量訪問到它的一個或者多個成員
a = "abcd"
print a[0] 第一個字符
print a[-1] 最後一個字符,也可以是print a[len(a)-1]
a[0: ] 輸出為abcd
a[0:1] 輸出為a
a[0:2] 輸出為ab
a[1:3] 輸出為bc 註意第一項不是0,那麽輸出項是從a[1]開始的3-1位,並不會輸出a[3]
a[:-1] 輸出為abc
五.替換字符串
a = "abc"
a.replace(‘a‘,‘hh‘)
‘hhbc‘
但是此時print a,輸出還是abc
六.字符串拼接
1.直接用加號來拼接,太耗資源,超級醜陋之千萬別用。
2.可選方案之字符串模板
用%s....%來拼接, %s表示要插入字符串,叫做占位符;%後面的字符表示要插入字符串的內容
占位符通常有2種,%s:字符串的占位符, %d:數字的占位符。
例如
1) print "my name is hong, %s" % "i am 18"
2) print "my name is %s %s" % ("hong","ten years old")
3.優秀的拼接方案
>>> a = "a"
>>> b = "bcd"
>>> c = "12cd"
>>> "".join([a,b,c])
‘abcd12cd‘
#用[]把abc變成一個list,才能進行拼接,直接用join(a,b,c)報錯,join裏面的參數只有一個列表是似乎更容易理解,如下的例子
info = "abc"
a=list(info)
a[2]=‘d‘
info="".join(a)
很好的把list變成了string
如果想把三個字符串用逗號分隔,只需在雙引號中寫入,即",".join([a,b,c])
練習題
a = ‘jay‘
b = ‘python‘
用字符串拼接的方法輸出:
my name is jay,i love python.
用方法二
>>> a=‘jay‘
>>> b=‘python‘
>>> print "my name is %s,i love %s" % ("a","b") #看來這裏的a,b 不能加引號
my name is a,i love b
>>> print "my name is %s,i love %s" % (a,b)
my name is jay,i love python
七.讀寫文本來了
d = open(‘a.txt‘,‘w‘)
d.write(‘hi,\nhello‘)
d.close()
d = open(‘a.txt‘,‘r‘)
help(d)
print d.readline
hi
print d.readline
hello
如果想讀取所有內容
print d.read(100),但是顯示為空
d.seek(0)來調整一下讀取位置
print d.read(100)就能看到全部信息量,100不夠就1000
w write
r read
a append
2017/8/15 8:59
基本數據類型1.3
一:類型
1 不可變數據類型
string,int ,tuple 常量
字符串不可變之再探
string[1] = ‘new_one‘ can?
例如:
a = "test" print a[0]輸出為t,此時若使a[0] = 1,就會報錯
說明字符串不可變
下面使用list的方式,list為可變對象
a = [1,2,3,4]
print a[0]輸出為1
a[0] = 4
print a[0]輸出為4,說明更改成功。
2 可變數據類型變量
dict list
二. 再研究字符串
序列到底是什麽
有先後順序的排序,就是序列
字符串就是一個序列
1 三個符合的區別 ‘‘,"",""" """
python中單雙引號沒區別,單引號裏可以寫雙引號,雙引號裏也可以寫單引號
一對三個雙引號作用是格式化的輸出多行內容,而且裏面的內容可以任意加單引號,雙引號等。例如
print """
author
"date"
‘money‘
"""
2 偏移量從0開始
3 如何修改字符串之replace,find
a = "my name is hong"
a.replace("my","his"),輸出為his name is hong.
但是這種方法並沒有修改a的原值,a的輸出還是my name is hong
如果想修改原值,可以重新賦值,比如
a = a.replace("my","his"),輸出為his name is hong
find
a.find("hong") 如果找到了字符串"hong"會返回一個整型,這個數值是a字符串對象hong第一個字母"h"的下標 ,如果找不到"hong",會返回-1
如果有多個hong,怎麽指定某一個hong呢,例如
a = "hong my name is hong"
此時用a.find("hong") 輸出結果會是0,就是從第0個字符開始的就是hong,怎麽找後面的那個hong呢
a.find("is") 輸出為13
a.find("hong",13)就會輸出is後面的hong了,註意用help(a.find)文檔
三. 格式化細究
1. % 格式化方式
復習占位符 %s,%d
a = "this is a %s" % "apple"
a = "this is a %s %s" % (4,10) 還可以強制把整型轉為字符串
輸出為 this is a 4 10,小括號裏的數據要按順序寫
2. format格式化方式
b = "this is {} {}" .format ("my","apple")為什麽要用format
print b
輸出為 this is my apple
如果想調整一下輸出參數的順序,那麽可以這樣寫
b = "this is {1} {0} .format ("my","apple"),那麽輸出結果就是
this is apple my
需要註意的是參數從0開始
算參數位置太麻煩,有時候還出錯,來種更人性化的方法
b = "this is {whose} {fruit}" .format (fruit="apple",whose="my")
print b
輸出為this is my apple
3. 還有一個方法,字典來了。
a = "this is %(whose)s %(fruit)s" % {‘whose‘:‘my‘,‘fruit‘:‘apple‘}
其中whose:my, whose是key位,my是word位
四. 再議打開文件
a = open("test.txt","w") #如果權限夠,會直接創建test.txt
a.write("hello, my name is hong")
#小括號內 只能寫字符串,而且必須加引號,如果寫1就會出錯
a.close
標準庫的介紹 linecache - Cache lines from files.
a = open("tmp.txt","w")
a.write("haha\n12faf\nhong")
a.close
在python命令行中輸出上面tmp文件的第一行,第二行內容。
import linecache
help(linecache)
print linecache.getline("tmp.txt",1)
print linecache.getline("tmp.txt",2)
...
四. 列表
1. 有序的集合
a = [1,2,3]
2 通過偏移來索引,從而讀取數據
a[-1]輸出為3
3 支持嵌套
b = [[1,2,3],[4,5,6]]
b的輸出為[[1,2,3],[4,5,6]]
此時如果想修改2為7,方法是b[0][1] = 7
4. 可變的類型
1) 切片:
a = [1,2,3,4,5,6,7]
正向索引
a[0:4:1] 表示從0位開始去到第4位,步長為1,結果為[1,2,3,4]
反向索引
a[-1:-4:-1],取到[7,6,5] #反向索引的步長一定要加上
默認索引
a[1:], 取到[2,3,4,5,6,7]
a[1::2], 取到[2,4,6]
2) 添加操作:
+ 生成一個新的列表
a = [1,2,3]
b = [4,5,6]
a + b 輸出為[1,2,3,4,5,6]
Extend,擴展list,參數為其他列表名,結果是新元素自動融入list,類型一樣。
接受參數並將該參數的每個元素都添加到原有的列表中,原地修改列表而不是新建列表
a.extend(b)
a的輸出為[1,2,3,4,5,6],對比操作前後的id(a),值是不變的
Append :添加任意對象到列表的末端,參數為單個元素,這個元素可以是數字,也可以是list或者元組本身。
a = [1,2,3]
a.append(4)
a的輸出為[1,2,3,4]
還可以加入列表
a.append([3,4,5])
a的輸出為[1,2,3,4,[3,4,5]]
Insert: 插入任意對象到列表中,可以控制插入位置。
a.insert(1,"ab") 表示在下標為1處加上元素“ab”
a的輸出結果是[1,"ab",2,3,4,[3,4,5]]
3) 修改:
修改列表本身只需要直接賦值操作就行。
A = [1,2,3]
A[0]=’haha’
4) 刪除操作:
Del :我們通過索引刪除指定位置的元素。
a = [1,2,3,4,5]
del a[0] #只有del是用命令del,其他都是通過 a.函數名 的方式調用實現相應功能。
a輸出為[2,3,4,5]
Remove:移除列表中指定值的第一個匹配值。如果沒找到的話,會拋異常。
a.remove(4)
a.remove(6)
Pop:返回最後一個元素,並從list中刪除它。
a.pop()
輸出為5,並刪除5
5. 成員關系:
通過in, not in的方法,我們可以判斷一個元素是否在列表裏。返回一個bool類型,元素在列表裏返回true,否則返回fasle.
a = [1,2,3]
2 in a
True
5 in a
False
5 not in a
True
6. 列表推導式:
[expr for iter_var in iterable]
1)首先叠代iterable裏所有內容,每一次叠代,都把iterable裏相應內容放到iter_var中,再在表達式中應用該iter_var的內容,最後用表達式的計算值生成一個列表。
比如我們要生成一個包含1到10的列表
方法一
[x for x in range(1,11)]
輸出為[1,2,3,4,5,6,7,8,9,10]
方法二
Range(1,11)
方法三
[expr for iter_var in iterable if cond_expr]
2)加入了判斷語句,只有滿足條件的內容才把iterable裏相應內容放到iter_var中,再在表達式中應用該iter_var的內容,最後用表達式的計算值生成一個列表。
要生成包含1到10的所有奇數列表。
方法一
range(1,11,2)
方法二
[x for x in range(1,11) if x % 2 == 1]
7. 排序翻轉:sort,reverse
sort
這個方式會直接修改原列表,它的返回值為none,所以b = a.sort() ,print b 輸出的內容是None
例如
a = [33,11,22,44]
b = a.sort()
b的輸出結果為None,也就是什麽都不輸出,可以用if語句判斷
if b is None:
print "haha"
此時再輸出a,發現a已經按順序排好,輸出為[11,22,33,44]
reverse和sort同理
b = a.reverse() #b的輸出也是None
再看a的輸出,發現a的值已經反轉了
[44,33,22,11]
2017/8/16
基礎篇10-列表應用
1. 內置list的方法
a = "asd"
list(a)
[‘a‘,‘s‘,‘d‘]
返回一個列表,參數是可叠代對象。裏面輸出的內容保持了傳入的可叠代對象的元素和順序
再傳一個元組
list((1,2))
[1,2]
但是如果傳入數字,就會報錯,因為數字是不可叠代的對象
list(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ‘int‘ object is not iterable
2.xrange和range的區別
xrange(開始,結束,步長)步長省略的話,默認為1
2個函數的區別:
xrange 會生成一個xrange對象,
range直接生成一個列表對象
例如
>>> a = xrange(1,10)
>>> a
xrange(1, 10)
>>> a[0]
1
>>> a[3]
4
>>> b = range(1,10)
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b[0]
1
>>> b[3]
4
xrange的使用場合
1. 當我們需要操作一個非常大的數據,而且內存比較吃緊的時候,我們可以用xrange來操作省內存
2. xrange一般用在循環裏面,比如我們只需要操作部分數據,而不是返回全部元素來完成操作,推薦使用xrange
比如
for m in range(1000): #生成一個包含[0-999]的對象
if m == 10:
print "sss"
break
for m in xrange(1000): #每一個叠代循環,只返回一個元素,只需返回[0-10],11個對象
if m == 10:
print "sss"
break
3. 列表推導式之再應用
例子1,取出1-100的所有值的平方
按從右向左的順序來寫,比較人性化,先寫一個1-100的序列,讓x叠代,然後左邊寫運算,最後加一個中括號
[x*x for x in range(100)]
裏面生成東西而不是數字
生成字符串
["the %s" %d for d in xrange(10)]
輸出為 ["the 0","the 1","the 2","the 3",...."the 9"]
生成元組
for x in range(2) 先生成一個列表,進行叠代
for y in range(2) 再生成一個列表,進行叠代
定義一個元組(x,y)
定義列表,也就是加上中括號
完整的句子就是:
[(x,y) for x in range(2) for y in range(2)]
輸出如下
[(0,0),(0,1),(1,0),(1,1)]
生成字典,就是上面的一個打包操作,加上dict()
dict([(x,y) for x in range(2) for y in range(2)])
輸出如下
{0:1,1:1}
冒號左為key,右為value, key如果相同,後面的key會覆蓋前面的key,所有(0,0),(0,1)只會有0:1, 1:1道理一樣。
4. 翻來覆去之再談引用
a = ["i","am","lilei"]
b = a #此時查看列表對象的地址,用id()查看,發現a,b的id值是一樣的,也就是引用的列表對象的存儲位置是一樣的。
a[2] = "laowang"
print b
這裏b的值是什麽?
b的值為[‘i‘,‘am‘,‘laowang‘]
del b
a
這裏的a是什麽值
a的值還是[‘i‘,‘am‘,‘laowang‘]
5. 小技巧之再議刪除
1)del a 刪除列表對象的引用
>>> a = [1,2,3]
>>> b = a
>>> del a
>>> b
[1, 2, 3]
2)del c[:] 清空列表對象裏的元素
>>> c = b
>>> del c[:]
>>> c
[]
>>> b
[]
習題
[]是引用 傳址調用
[:] 是復制 傳值調用
a = [1,2,3]
b = a[:] #這個[:]是個什麽東西
del a
b的值是什麽。為什麽呢?
當b=a時
>>> a=[1,2,3]
>>> b=a
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> id(a)
140076707413024
>>> id(b)
140076707413024
當b=a[:]時
#這裏生成了一個新的列表對象,b的變化,不會影響下面a的輸出。
>>> a=[1,2,3]
>>> b=a[:]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> id(a)
140076707334048
>>> id(b)
140076707335272
>>> b=[1,2,3,4]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3, 4]
2017/8/17 8:52
基礎篇11-元組和集合
1. 元組是有序的集合
a = (1,2,3)
2. 通過偏移來取數據,也是通過下標來取,和列表一樣。區別就是list是可變的,元組是不可變的。
a[0] 輸出為1
a[1:3] 輸出為(2,3)
3. 屬於不可變的對象,不能在原地修改內容,沒有排序,修改等操作。
dir(a)可以看到所有支持的方法
要想修改元組,需要先把元組重新賦值給一個列表,然後修改列表元素,之後再把列表轉變給元組。方法如下
b = list(a)
b[0] = 5
type(b) 輸出為list
a = tuple(b) #生成了一個新的元組對象
a
輸出為(5,2,3)
tuple類型轉換
那為什麽有列表還要有元組呢?
元組不可變的好處。保證數據的安全,比如我們傳給一個不熟悉的方法或者數據接口,確保方法或者接口不會改變我們的數據從而導致程序問題。
例子1
#encoding=utf-8
def info(a):
print "id %d" % id(a)
#a[0] = "haha" 第一個腳本完成後加這行進行測試
#return a 這行也是測試的
a = [1,2,3]
print "start-"
print id(a)
info(a)
#print a 測試用的
另外一種方法
#encoding=utf-8
def info(a):
b = a[:] #這裏生成了一個新的列表對象,b的變化,不會影響下面a的輸出。
b[0] = "haha"
return a
a = [1,2,3]
print "start-"
print id(a)
info(a)
print a
二. 集合
集合是沒有順序的概念。所以不能用切片和索引操作。
1. 創建集合
set():可變的
a = set("abc")
a
輸出為set([‘a‘, ‘c‘, ‘b‘])
不可變的frozenset():
>>> a = frozenset("abc")
>>> a
frozenset([‘a‘, ‘c‘, ‘b‘])
>>> a.add("222")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘frozenset‘ object has no attribute ‘add‘
>>> a.remove("a")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘frozenset‘ object has no attribute ‘remove‘
查看對象是否可叠代的方法
用dir進行查看,比如dir(a),如果輸出中有"_iter_",說明可以進行叠代。
2. 添加操作: add,update
add函數
a.add("python")
a
輸出為
set([‘a‘, ‘python‘, ‘c‘, ‘b‘]) #"python"做為一個整體來加入。
update函數
>>> b = set("hong")
>>> b
set([‘h‘, ‘g‘, ‘o‘, ‘n‘])
>>> b.update("python")
>>> b
set([‘g‘, ‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘]) #python分開來插入,如果重復自動忽略
註意:
update的參數也可以是list,如果使用list,那麽集合中新加的元素還會保持原先list中的順序。
比如c=‘hong‘
b.update(list(c))
3. 刪除 remove
a.remove("python")
a
輸出為
set([‘a‘, ‘c‘, ‘b‘])
4. 成員關系 in,not in
"c" in a
True
"h" not in a
True
5. 交集,並集,差集 & | -
a = set(‘abcd‘)
b = set(‘bcdef‘)
a & b
set([‘c‘,‘b‘,‘d‘])
a | b #並集
set([‘a‘,‘c‘,‘b‘,‘e‘,‘d‘,‘f‘])
a - b #差集
set([‘a‘])
6. set去重
例子
>>> a = [1,2,3]
>>> a.append(1)
>>> a.append(3)
>>> a
[1, 2, 3, 1, 3]
>>> set(a)
set([1, 2, 3])
>>> list(set(a))
[1, 2, 3]
基礎篇12-字典
字典是無序的,它不能通過偏移來存取,只能通過鍵來存取。
例1
>>> info = {‘a‘:1,‘b‘:2}
>>> info
{‘a‘: 1, ‘b‘: 2}
可以通過鍵值返回value值
>>> info[‘a‘]
1
例2
>>> binfo = {‘a‘:[1,2,3],‘b‘:[4,5,6]}
>>> binfo
{‘a‘: [1, 2, 3], ‘b‘: [4, 5, 6]}
>>> binfo[‘a‘][2] = 5
>>> binfo
{‘a‘: [1, 2, 5], ‘b‘: [4, 5, 6]} #說明字典是可變的類型。
字典 = {‘key‘:value} key:類似我們現實的鑰匙,而value則是鎖。一個鑰匙開一個鎖
特點:
內部沒有順序,通過鍵來讀取內容,
可嵌套,方便我們組織多種數據結構,並且可以原地修改裏面的內容,屬於可變類型。
組成字典的鍵必須是不可變的數據類型,比如,數字,字符串,元組等,列表等可變對象不能作為鍵.
例3
key 為數字
>>> binfo = {1:"22",2:"dd"}
>>> binfo
{1: ‘22‘, 2: ‘dd‘}
key為字符串
>>> cinfo = {"a":"222","b":111}
>>> cinfo
{‘a‘: ‘222‘, ‘b‘: 111}
key為元組,需要註意的是元組中的元素也必須是不可變類型。
>>> dinfo = {(1,2,3):‘ss‘,(‘b‘,‘c‘):‘222‘}
>>> dinfo
{(‘b‘, ‘c‘): ‘222‘, (1, 2, 3): ‘ss‘}
元組中的元素是列表
>>> xinfo = {(1,‘2‘,[2,3]):‘a‘}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: ‘list‘
key為列表
>>> finfo = {[1,2,3]:‘sss‘}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: ‘list‘
1. 創建字典。{},dict()
法1
info = {‘name‘:‘lilei‘, ‘age‘: 20}---------------一般情況下還是用法一好!
法2
info = dict(name=‘lilei‘,age=20)
name是key,‘lilei‘是value
註意:
1. 法一是用花括號,法二是用小括號;
2. 法一key和value中的字符串必須加引號;法二key的字符串可以不用加雙引號,value的字符串必須加雙引號。
3. 法一用冒號,法二用等號
2. 添加內容 a[‘xx‘] = ‘xx‘
比如在法1例子的基礎上加上如下命令
info[‘phone‘] = ‘iphone5‘,其中phone為key, iphone5為value
>>> info ={‘name‘:‘lilei‘,‘age‘:20}
>>> info
{‘age‘: 20, ‘name‘: ‘lilei‘}
>>> info[‘phone‘] = ‘iphone5‘
>>> info
{‘phone‘: ‘iphone5‘, ‘age‘: 20, ‘name‘: ‘lilei‘}
3. 修改內容 a[‘xx‘] = ‘xx‘
info[‘phone‘] = ‘htc‘
update 參數是一個字典的類型,他會覆蓋相同鍵的值
在例2的基礎上做下面操作
>>> info.update({‘city‘:‘beijing‘,‘phone‘:‘nokia‘})
>>> info
{‘phone‘: ‘nokia‘, ‘age‘: 20, ‘name‘: ‘lilei‘, ‘city‘: ‘beijing‘}
4. 刪除 del,clear,pop
1)del ainfo[‘phone‘] 刪除某個元素
>>> ainfo = {‘age‘:22,‘aa‘:22}
>>> ainfo
{‘aa‘: 22, ‘age‘: 22}
>>> del ainfo[‘aa‘] #刪除‘aa‘元素
>>> ainfo
{‘age‘: 22}
刪除ainfo的引用
>>> del ainfo
>>> ainfo
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name ‘ainfo‘ is not defined
2)clear()刪除字典的全部元素
>>> a = {‘info‘:‘22‘,‘age‘:‘34‘}
>>> a
{‘info‘: ‘22‘, ‘age‘: ‘34‘}
>>> a.clear()
>>> a
{}
3)pop(‘name‘)
字典的pop方法
>>> a = {‘11‘:‘aa‘,‘bb‘:22}
>>> a
{‘11‘: ‘aa‘, ‘bb‘: 22}
>>> a.pop(‘bb‘) #傳入需要刪除目標的key,就可刪除。
22
>>> a
{‘11‘: ‘aa‘}
需要註意的是,如果pop的key不存在,我們可以指定一個輸出值讓系統顯示出來,
以上面字典a為例
>>> a.pop(‘33‘)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: ‘33‘
>>> a.pop(‘33‘,‘not exist‘)
‘not exist‘
列表的pop方法
>>> binfo = []
>>> binfo.append(‘22‘)
>>> binfo.append(‘234‘)
>>> binfo
[‘22‘, ‘234‘]
>>> binfo.pop(0) #傳的是索引下標
‘22‘
>>> binfo
[‘234‘]
5. in 和 has_key() 成員關系操作
例如
>>> a
{‘11‘: ‘aa‘, ‘bb‘: 22}
1).in
>>> "phone" in a
False
2) a.has_key()
>>> a.has_key(‘11‘)
True
>>> a.has_key(‘aa‘)
False
3). keys(): 返回的是列表,裏面包含了字典的所有鍵
>>> a.keys()
[‘11‘, ‘bb‘]
4). values():返回的是列表,裏面包含了字典的所有值
>>> a.values()
[‘aa‘, 22]
5) items():生成一個字典的容器:------這個方法是字典轉變為list的途徑
>>> a.items()
[(‘11‘, ‘aa‘), (‘bb‘, 22)].裏面的每一項都是一個元組,元組第一項為key,第
二項為value
6) get:從字典中獲得一個值
>>> a.get(‘11‘) #參數為key,輸出為value
‘aa‘
>>> a.get(‘33‘) #key不存在,輸出為空,且為NoneType類型
>>> b = a.get(‘33‘)
>>> type(b)
<type ‘NoneType‘>
>>> a.get(‘33‘,‘not exist‘) #key不存在,可以指定默認輸出值
‘not exist‘
基礎篇13-答疑課
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)] ##這裏不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##這裏不明白
一. 先得講講二進制
0 + 1 + 1 9 +1 = 10
99 +1 = 100
2進制馮二進1
0 +1 = 1
1 +1 = 10
10 +1 = 11
11 +1 = 100
100 + 1 = 101
101 + 1 = 110
二. 難纏符號來啦
bin:把10進制轉換為2進制
例子
>>> bin(3)
‘0b11‘
只看0b後面的數值,就是轉換後的2進制
1.難纏符號之一 >> <<
位移,移動的是2進制的位
例子
>>> 5 >> 1
2
5的2進制是101,向右邊移動一位,結果就是10,十進制結果就是2
>>> 3 << 1
6
3的二進制是11,左移一位變為110,十進制就是6
2.難纏符號之二 &
按位與,對應位都是1結果才是1,其他都是0
1100
1000
1000
例子
>>> 10 & 20
0
10的2進制:01010 #第一位的0是補的
20的2進制:10100
發現沒有一個對應位是1的,所有結果是全0.
>>> 40 & 32
32
註意2進制轉變為10進制
>>> int(0b100000)
32
3.難纏符號之三 |
按位或,對應位只需一個為1,結果就是1
0100000
1100100
1100100
例子
32 | 100
100
4.難纏符號之四 ^
按位異或,對位相加,不進位
101
011
110
5.難纏符號之五 ~
按位取反,2進制數加1後,乘以-1
例如~5 = -6
~5=-(101+1)=-110=-6
所以
3+~5=-3
註意不能直接寫3~5,這樣是錯的
三. 其他
1.&之奇偶判定,和1進行按位與運算,結果為1就是奇數,結果為0則是偶數
5 & 1
1
4 & 1
0
2.計算硬盤容量
比如一個文件大小是11866字節,想知道有多少k,那就是向右移10位,相當於11866除以2的10次方,相應的,想知道有多少M,就向右邊移動20位。
11866 >> 10
3.真真假假不知曉
False & True & True
False
True & True & True
True
if is_boy() & is_18() & is_chinese():
print
四.回過頭來再看這道題
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)] ##這裏不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##這裏不明白
2017/8/18 9:57
基礎篇15. 答疑課之二:再議數據結構與數據類型
1.list,dict,tuple之它們其實是好基友
1.1 沒有最優秀的數據結構,只有最適用的
1.2 了解每個結構的特點才能活學活用
1.3 它們相互轉換如此簡單
list是有序的
dict是無序的,適合存儲有復雜名稱的數據,比如{"xiaoming":86},比如電話薄,班級成績單。
a = (1,2,3,4)
a = list(a) #元組轉換成list
然後把list轉變成tuple
a = tuple(a)
list轉換成字典
a = [(1,3),(2,4)]
a = dict(a)
2.“推倒式”(列表推導)與再議
[x for x in xrange[101]
第一部分 []
第二部分 x
第三部分 for x in xrange[101]
等價於
new_list = []
for x in xrange(101):
new_list.append(x) #這裏的x等同於第二部分的x
print new_list
3.排序
3.1 sorted--------可以用在字符串中進行排序,會生成一個list
help(‘sorted‘)來看幫助文檔
a = [1,2,3,4]
sorted(a,reverse=True)
[4,3,2,1]
a
[1,2,3,4] #說明sorted並不是原地修改
要想修改a的值,需要賦值
a = sorted(a,reverse=True)
3.2 list之sort方法
a = [1,2,3,4]
a.sort(reverse=True)
a
[4,3,2,1] 說明內置函數sort是原地修改
sort幫助文檔中的信息
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
key最好用,它可以對list中的元素進行操作
例1
>>> a = ["43214","324214","82310","9231"]
>>> a.sort(key=int)
>>> a
[‘9231‘, ‘43214‘, ‘82310‘, ‘324214‘]
>>> a.sort(key=int,reverse=True)
>>> a
[‘324214‘, ‘82310‘, ‘43214‘, ‘9231‘]
例子2,按照list中元組元素的第2個數字大小進行排序
>>> a = [(‘a‘,2),(‘b‘,5),(‘c‘,4)]
>>> a.sort(key=lambda x:x[1]) #x表示每一個元組單元,x[1]表示元組中下標為1的元素,也就是數字2,5,4.
>>> a
[(‘a‘, 2), (‘c‘, 4), (‘b‘, 5)]
>>> a.sort(key=lambda x:x[1],reverse=True)
>>> a
[(‘b‘, 5), (‘c‘, 4), (‘a‘, 2)]
cmp是什麽
cmp是用來比較2個數字的值,只會返回三個結果:0,1,-1. 能用key最好不用cmp,python3中已經棄用,性能不好
用法
cmp(a,b) 等同於公式(a>b) - (a<b)
>>> cmp(1,3)
-1
>>> (1>3) - (1<3)
-1
>>> cmp (3,1)
1
>>> cmp (3,3)
0
3.3 多級排序咋個辦
如下,按元組元素中的後兩位數字進行排序,我的理解就是後兩位看做一個數比大小。
>>> a = [(3,1,2),(6,7,8),(6,5,9)]
>>> import operator
>>> a.sort(key=operator.itemgetter(1,2)) #這裏的1,2表示下標。
>>> a
[(3, 1, 2), (6, 5, 9), (6, 7, 8)]
3.4 字典如何去排序
自己摸索。。。
4.字符串模板應用
4.1 回憶一下,字符串模板有哪幾種方式
"%s is a %s" %("he","boy")
"%(who)s is a %(gender)s" %{"who":"he","gender":"boy"}
"{who} is a {gender}".format(who="he",gender="boy") 這種最好
4.2 典型應用1:html模板
也是用占位符來替代相應模塊中的內容
4.3 針對性比強大更為重要
三種字符串模板靈活運用,看哪個適用
基礎篇16-python語句講解1
1. print語句
1.1 基本輸出
1.2 print的逗號
1.2 輸出到文件 >>為重定向
解釋與例子
在python腳本中,如果寫入
print "2"
print "3"
那麽執行的時候會自動進行換行,輸出為
2
3
如果腳本中加上逗號,如下
print "2",
print "3"
那麽執行的時候輸出就是
2 3
不會進行換行,所有逗號的意思就是print語句還沒執行完。
輸出重定向,使用print命令來寫文件內容 -----以後我就用這個方法吧,命令行也行
腳本中如下寫
f = open(‘print.txt‘,‘w‘)
#一般情況下寫入文件應該用命令f.write("my name is hong"),這裏用print來寫
print >> f,"my name is hong"
print >> f,"i am from china"
f.close()
這裏當然也可以用逗號,來使2行變一行。
2. 控制流語句(control flow)
2.1 由條件和執行代碼塊組成。
2.1.1 條件可分為決策、循環和分支
2.2 格式(冒號與4個空格永不忘)
2.3 if,while,for 函數,皆為contorl flow
解釋和例子
if True: #冒號分隔了條件和代碼塊。
print 4 #4個空格縮進的代碼塊
x = 3
if x: #相當於 if x == if bool(x),返回結果為True
print 4
3. 布爾值
3.1 控制流與真假值息息相關
3.1.1 不要誤解了真假與布爾值
3.2 布爾值的幾個最基本運算符
3.2.1 and 全部都為bool真
3.2.2 or 至少一個為bool真
3.2.3 is 檢查共享
3.2.4 == 檢查值
3.2.5 not
3.2.6 其他若幹比較符號
>>> True and False
False
>>> True or False
True
is是檢查是否引用了同一個數據對象
>>> 5 is True
False
5是引用了一個整型的數據對象,True引用的是一個布爾類型的對象,所有結果是False
>>> a = 5
>>> b = 5
>>> a is b
True
== 檢查左邊和右邊的值是否相同
1 == True
True
雖然左邊是整型,右邊是布爾型,但是他們的值都是1,所以返回True
>>> 4 == 9
False
not:取反。如果要表示真,後面一定要跟False,做這個的是太無聊了,整點花樣。
if not False:
print "not False"
4. if語句 (控制流語句)
4.1 if的組成 if else elif pass
4.1.1 if與elif替代了switch
4.1.2 pass
例子
if True:
print "True"
else:
print "False"
if True:
print "True"
elif not True:
print "not True"
else:
pass #什麽都不做
4.2 奇技淫巧 三元表達式
4.2.1 x if else
4.2.2 活用list
4.2.3 三元表達式玩玩就好
例子1
4 if True else 3
等同於
if True:
print 4
else:
print 3
>>> 4 if True else 3
4
例子2
>>> [4,3][True] #True值為1,所以返回下標為1的list值
3
>>> [4,3][False] #False值為0,所以返回下標為0的list值
4
>>> [4,3][0]
4
>>> [4,3][1]
3
基礎篇17-python語句講解-2
1.復習
1.1 控制流的基本組成部分 條件,執行代碼塊。
1.2 if的基本格式
if expression:
statement(s)
1.2 控制流的條件表達式(expression)結果,必須為True(真),比如 條件可以寫成if not True: 這樣的返回結果為真,而不能寫成if False,返回為假
1.3 冒號永不忘。盡量使用4個空格,而不是制表符
2.while語句
2.1 while的基本格式
while expression:
statement(s)
例子1
x = 1
while True:
x += 1
print x
#continue 通過加減這個命令來測試
if x > 20:
break
else:
2.2 while的基本組成部分
2.2.1 break 結束while
2.2.2 continue 跳出當前這次循環,但不結束while
2.2.3 else 結束while以後執行,是正常跑完,不是通過break強行結束。也就是說不能和break連用,不然break會把else語句也掐斷。但是可以和continue一起用
while x < 20: #可以在while表達式中用<
x += 1
#continue 來測試是否能和continue一起用
print x
else:
print "end"
2.3 註意:普通應用裏,while一定要給一個結束條件,否則就是傳說中的死循環
3.for語句
3.1 for的基本格式
for item in iterable:
statement(s)
例子
for x in "hello,my name is hongjin"
print x
消除空格
for x in "hello,my name is hongjin".split(" "):
print x
用一行來顯示出來文本內容
for x in "hello,my name is hongjin".split(" "):
print x,
3.2 for的基本組成部分
3.2.1 break
3.2.2 continue
3.2.3 else
3.3 註意:for的最後一個叠代值將保留,也就是循環結束後,最後一個循環取得值將被保留在內存中。如果不註意的話,可能會出現錯誤
4.布爾值再議
4.1 惰性求值,需要時再求值。
4.2 從左到右,從先到後。
4.3 利用小技巧。or之默認值。
比如
True and False and False and True
python在進行計算時,看到第二個是False,後面的就不計算了,直接返回False
在進行運算時,可以把可能是false的計算放在前面,把其他運算量很大的計算放後面,這樣效率高
or之默認值
比如在爬網頁的時候
http://reg.email.163.com&from=126mail
定義一個變量
from_url = url.get("from") or None
就是爬上面的網址from後面的參數"=126mail",有時候from後面有內容,有時候沒有,如果沒有的話,腳本還想繼續運行,就需要加上or None
基礎篇18-語句與數據結構應用
1.最基本的叠代
a = "abcdefg"
for i in a:
print i
b = [1,2,3,4,5]
for i in b:
print i
2.如何叠代字典
a = {"key":"value","key1":"value1"}
print a
a = {"key":"value","key1":"value1","key1":"value2"}
print a
相同的key,只會輸出最後一個key的value
for i in a.keys():
print i
命令行中看一下a.items()是什麽
腳本中
for x,y in a.items():
print x,y
3.如何為字典排序
例子1,把下面字典元素按照key中的字母序列排序
a = {"a":"haha","b":"xs","d":"fa","c":"faff"}
key_list = a.keys()
key_list.sort()
#print key_list
for x in key_list:
print x,a[x]
註意:字典可以使用如下方式查看字典的value
>>> print a["a"]
haha
4.字典根據鍵值查找鍵
那麽如果想從字典的value得到key,應該怎麽做呢
分析:
1) 字典索引的是鍵,而不是值 => 叠代,窮舉
2) 字典具有唯一鍵,但值不要求唯一
3) 一個值可能對應多個鍵
例子,不同的key都有相同的value值,
a = {"a":"haha","b":"xixi","d":"haha","e":"xixixi","c":"haha"}
search_value = "haha"
key_list = []
for x,y in a.items(): #找到所有的key, value, for x,y :設置兩個參數,這個思想很牛x
# print x,y
if y == search_value: #建立相同value對應的key_list
key_list.append(x)
print key_list
5.sorted排序方法再議
在python腳本中這樣寫
import string #測試下不引入string時的輸出情況。
a = "dcDSfag1f43"
a = ‘‘.join([x for x in a if not x.isdigit()])
print sorted(a,key=string.upper)
執行後輸出為
hong@calm:~$ python test.py
[‘a‘, ‘c‘, ‘d‘, ‘D‘, ‘f‘, ‘f‘, ‘g‘, ‘S‘]
註意:
key=string.upper可以理解為
1.用string.upper這個方法,去執行列表中的每一個數據,假設我們有一個list
c = [a,b,c]
sorted(c,key=string.upper)相當於先生成一個新的列表
c = [string.upper(a),string.upper(b),string.upper(c)],然後對這個新的列表進行排序。
結論:
[x for x in a if not x.isdigt()] 等價於下面代碼
new_list = []
for x in a:
if not x.isdigit():
new_list.append(x)
6. 好玩的translate與maketrans---替換字符
例子1
>>> import string
>>> g = string.maketrans(‘123‘,‘abc‘) #建立翻譯表,參數中的‘123‘和‘abc‘位數必須一致,因為它是一一對應翻譯的,否則會報錯
>>> a = ‘123456‘
>>> print a.translate(g)
abc456
例子2
>>> a = ‘321123132‘
>>> print a.translate(g)
cbaabcacb
對比replace
>>> a.replace(‘123‘,‘abc‘)
‘321abc132‘
例子3,刪除操作
>>> a = ‘321123132‘
>>> a.translate(g,‘1‘) #輸出刪除1後對應的翻譯
‘cbbccb‘
如果不翻譯,輸出刪除1後的結果
>>> c = string.maketrans(‘‘,‘‘)
>>> a.translate(c,‘1‘)
‘322332‘
>>> a.translate(c,‘12‘)
‘333‘
逐個刪除。
7. 一個新的語句,with,一個寫文件的方法
普通方法
g = open(‘a.txt‘,‘w‘)
g.write(‘hello,\nhi‘)
g.close()
with方法
with open(‘a.txt‘,‘a‘) as g: #參數a表示append
g.write("hello")
這種方法不需要寫close語句
2017/8/20 8:58
基礎篇20-python函數
一. 定義函數
1. def是關鍵字,括號冒號永不忘,執行代碼塊要縮進
2. 沒有return的函數,不是真函數
3. 不寫doc的函數,就像沒有性別的人類,也就是要在函數中寫說明,直接在def test():下一行用雙引號寫下說明就行了
例子1
def test():
print 4
test()
上面這個寫法是錯誤的,應該如下寫
def test():
return 4
print test()
例子2
#coding=utf-8
def test():
"這是一個測試函數"
return 1
print test.__doc__
#這個命令是直接打出函數說明信息的,也就是執行python test.py時,會輸出"這是一個測試函數", 需要註意的是doc前面和後面是2個下劃線。
二. 函數的參數
1) 位置參數
def test(a,b,c,d):
return a,b,c,d #這樣的結果是會返回一個元組(1,2,3,4)
print test(1,2,3,4) #定義的時候有幾個位置參數,這裏就要寫幾個數,否則會報錯
2)可選參數,直白意思就是調用函數的時候參數寫不寫都行,不會報錯。
def test1(a=4)
return a
print test1()
輸出結果是4
print test1(5)
輸出結果是5
3)可選參數可以當做默認值進行設置
例子, 下面是偽代碼,知道意思就好
def test2(a,b,c return_data="json"):
if return_data == ‘json‘:
return json(a,b,c)
elif return_data == ‘xml‘:
return xml(a,b,c)
return a,b,c
test2(1,2,3,return_data=‘xml)
2. 參數的值是局部變量
1)全局變量和局部變量
例1,在腳本中如下寫
b = 3 #全局變量
def a():
#global b
b = 4 #局部變量
return b
def c():
return b
print a()
print c()
結果輸出為
4
3
說明在局部變量和全局變量中都定義一個變量的時候,會優先使用局部變量的值,如果局部變量沒有定義,則會自動使用全局變量值
如果想在函數a中修改全局變量b的值,方法是使用global b,那麽此時print c()的值也是4了,說明全局變量修改成功,這個方法慎用。
2)如何修改參數
例子
有一個list b = [1,2,3],想通過一個函數func(b),實現結果為把list b =[1,2,3,4], 方法如下
b = [1,2,3]
def func(x) #定義函數有一個參數
x.append(4)
return x
b = func(b)
#調用函數func,並且把返回值重新賦值給b,雖然不用賦值給b,結果也是正確的,但這不是一個好的編程習慣。
print b
3) 函數的參數魔法 ----- **和* 星星是字典,星是元組
例子1
def test(**kr):
return kr #kr可以是任意字符,表示字典名
print test(a=4,c=3)
輸出結果為{‘a‘:4, ‘c‘:3}
例子2
def test(*z):
return z
print test(1,2,[1,2])
輸出結果為(1,2,[1,2])
例子3
def test(*z,**kr):
return z,kr
print test(1,2,a=5,b=9)
輸出結果為 ((1, 2), {‘a‘: 5, ‘b‘: 9})
註意:
參數a=5這樣的參數必須是一起寫在1,2這樣的參數後面。修改test(*z,**kr)的參數位置也不行。
例子4
def test(a,b,*z,**kr)
return z,kr
print test(1,2,4,5,c=4,d=9)
如果定義參數的時候,已經有了位置參數,那麽在print test寫入實參的時候是按照形參的順序來寫入的
實參中的c,d在定義中必須是沒有c,d的,不然就會報錯。
python基礎知識點