python對象的相關術語：
python程序中保存的所有數據都是圍繞對象這個概念展開的：
- 程序中存儲的所有數據都是對象
- 每個對象都有一個身份、一個類型和一個值
例如，school='MaGe Linux'會以'MaGe Linux'創建一個字符串對象，其身份是指向它在內存中所處位置的指針(其在內存中的地址),而school就是引用這個具體位置的名稱
- 對象的類型也稱對象的類別，用於描述對象的內部表示及它支持的方法和操作
- 創建特定類型的對象時，有時也將該對象稱為該類型的實例
- 實例被創建后，其身份和類型就不可改變
如果對象的值是可修改的，則稱為可變對象
如果對象的值不可修改，則稱為不可變對象
- 如果某個對象包含對其他對象的引用，則將其稱為容器
- 大多數對象都擁有大量特有的數據屬性和方法
屬性：與對象相關的值
方法：被調用時將在對象上執行某些操作的函數
使用點(.)運算符可以訪問屬性和方法
對象的身份與類型：
python內置函數id()可返回一個對象的身份，即該對象在內存中的位置
- is 運算符用於比較兩個對象的身份
- type() 用於返回一個對象的類型
- 對象類型本身也是一個對象，稱為對象的類
(1)該對象的定義是唯一的，且對於某類型的所有實例都是相同的
(2)所有類型對象都有一個指定的名稱，可用於執行類型檢查,如list、dict
示例： >>> num1 = 5 >>> num2 = 5 >>> num1 == num2 #值比較 >>> True >>> id(num1) #內存中的地址 9119808 >>> id(num2) 9119808 >>> num1 is num2 #身份比較 True >>> type(num1) is type(num2) #類型比較 True
運算符
一、算數運算：
二、比較運算：
三、賦值運算：
四、邏輯運算：
五、成員運算：
六、身份運算：
七、位運算：
1byte = 8bit
2**8 2**7 2**6 2**5 2**4 2**3 2**2 2**1 2**0
256 128 64 32 16 8 4 2 1
以下實例演示了Python所有位運算符的操作：
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0 c = a & b; # 12 = 0000 1100 print "1 - c 的值為：", c c = a | b; # 61 = 0011 1101 print "2 - c 的值為：", c c = a ^ b; # 49 = 0011 0001 print "3 - c 的值為：", c c = ~a; # -61 = 1100 0011 print "4 - c 的值為：", c c = a << 2; # 240 = 1111 0000 print "5 - c 的值為：", c c = a >> 2; # 15 = 0000 1111 print "6 - c 的值為：", c
八、運算符優先級：
更多內容：猛擊這里
數據類型
核心數據類型：
- 數字：int, long(python3.5已經沒有), float, complex, bool
- 字符：str, unicode
- 列表：list
- 字典：dict
- 元組：tuple
- 集合：set(可變集合),frozenset(不可變集合)
- 文件：file
數字類型：
python的數字字面量：整數，布爾型，浮點數，復數，所有數字類型均為不可變
int（整型）
在32位機器上，整數的位數為32位，取值范圍為-2**31～2**31-1，即-2147483648～2147483647
在64位系統上，整數的位數為64位，取值范圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807
在64位系統上，整數的位數為64位，取值范圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807
bool(布爾型)
真或假
1 或 0
float(浮點型)
數字操作：+ , -, *, /, //, **, %, -x, +x
附上源碼：
class int(object): """ int(x=0) -> int or long int(x, base=10) -> int or long Convert a number or string to an integer, or return 0 if no arguments are given. If x is floating point, the conversion truncates towards zero. If x is outside the integer range, the function returns a long instead. If x is not a number or if base is given, then x must be a string or Unicode object representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) """ def bit_length(self): """ 返回表示該數字的時占用的最少位數 """ """ int.bit_length() -> int Number of bits necessary to represent self in binary. >>> bin(37) '0b100101' >>> (37).bit_length() """ return 0 def conjugate(self, *args, **kwargs): # real signature unknown """ 返回該復數的共軛復數 """ """ Returns self, the complex conjugate of any int. """ pass def __abs__(self): """ 返回絕對值 """ """ x.__abs__() <==> abs(x) """ pass def __add__(self, y): """ x.__add__(y) <==> x+y """ pass def __and__(self, y): """ x.__and__(y) <==> x&y """ pass def __cmp__(self, y): """ 比較兩個數大小 """ """ x.__cmp__(y) <==> cmp(x,y) """ pass def __coerce__(self, y): """ 強制生成一個元組 """ """ x.__coerce__(y) <==> coerce(x, y) """ pass def __divmod__(self, y): """ 相除，得到商和余數組成的元組 """ """ x.__divmod__(y) <==> divmod(x, y) """ pass def __div__(self, y): """ x.__div__(y) <==> x/y """ pass def __float__(self): """ 轉換為浮點類型 """ """ x.__float__() <==> float(x) """ pass def __floordiv__(self, y): """ x.__floordiv__(y) <==> x//y """ pass def __format__(self, *args, **kwargs): # real signature unknown pass def __getattribute__(self, name): """ x.__getattribute__('name') <==> x.name """ pass def __getnewargs__(self, *args, **kwargs): # real signature unknown """ 內部調用 __new__方法或創建對象時傳入參數使用 """ pass def __hash__(self): """如果對象object為哈希表類型，返回對象object的哈希值。哈希值為整數。在字典查找中，哈希值用於快速比較字典的鍵。兩個數值如果相等，則哈希值也相等。""" """ x.__hash__() <==> hash(x) """ pass def __hex__(self): """ 返回當前數的 十六進制 表示 """ """ x.__hex__() <==> hex(x) """ pass def __index__(self): """ 用於切片，數字無意義 """ """ x[y:z] <==> x[y.__index__():z.__index__()] """ pass def __init__(self, x, base=10): # known special case of int.__init__ """ 構造方法，執行 x = 123 或 x = int(10) 時，自動調用，暫時忽略 """ """ int(x=0) -> int or long int(x, base=10) -> int or long Convert a number or string to an integer, or return 0 if no arguments are given. If x is floating point, the conversion truncates towards zero. If x is outside the integer range, the function returns a long instead. If x is not a number or if base is given, then x must be a string or Unicode object representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) # (copied from class doc) """ pass def __int__(self): """ 轉換為整數 """ """ x.__int__() <==> int(x) """ pass def __invert__(self): """ x.__invert__() <==> ~x """ pass def __long__(self): """ 轉換為長整數 """ """ x.__long__() <==> long(x) """ pass def __lshift__(self, y): """ x.__lshift__(y) <==> x<<y """ pass def __mod__(self, y): """ x.__mod__(y) <==> x%y """ pass def __mul__(self, y): """ x.__mul__(y) <==> x*y """ pass def __neg__(self): """ x.__neg__() <==> -x """ pass @staticmethod # known case of __new__ def __new__(S, *more): """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ pass def __nonzero__(self): """ x.__nonzero__() <==> x != 0 """ pass def __oct__(self): """ 返回改值的 八進制 表示 """ """ x.__oct__() <==> oct(x) """ pass def __or__(self, y): """ x.__or__(y) <==> x|y """ pass def __pos__(self): """ x.__pos__() <==> +x """ pass def __pow__(self, y, z=None): """ 冪，次方 """ """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """ pass def __radd__(self, y): """ x.__radd__(y) <==> y+x """ pass def __rand__(self, y): """ x.__rand__(y) <==> y&x """ pass def __rdivmod__(self, y): """ x.__rdivmod__(y) <==> divmod(y, x) """ pass def __rdiv__(self, y): """ x.__rdiv__(y) <==> y/x """ pass def __repr__(self): """轉化為解釋器可讀取的形式 """ """ x.__repr__() <==> repr(x) """ pass def __str__(self): """轉換為人閱讀的形式，如果沒有適於人閱讀的解釋形式的話，則返回解釋器課閱讀的形式""" """ x.__str__() <==> str(x) """ pass def __rfloordiv__(self, y): """ x.__rfloordiv__(y) <==> y//x """ pass def __rlshift__(self, y): """ x.__rlshift__(y) <==> y<<x """ pass def __rmod__(self, y): """ x.__rmod__(y) <==> y%x """ pass def __rmul__(self, y): """ x.__rmul__(y) <==> y*x """ pass def __ror__(self, y): """ x.__ror__(y) <==> y|x """ pass def __rpow__(self, x, z=None): """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """ pass def __rrshift__(self, y): """ x.__rrshift__(y) <==> y>>x """ pass def __rshift__(self, y): """ x.__rshift__(y) <==> x>>y """ pass def __rsub__(self, y): """ x.__rsub__(y) <==> y-x """ pass def __rtruediv__(self, y): """ x.__rtruediv__(y) <==> y/x """ pass def __rxor__(self, y): """ x.__rxor__(y) <==> y^x """ pass def __sub__(self, y): """ x.__sub__(y) <==> x-y """ pass def __truediv__(self, y): """ x.__truediv__(y) <==> x/y """ pass def __trunc__(self, *args, **kwargs): """ 返回數值被截取為整形的值，在整形中無意義 """ pass def __xor__(self, y): """ x.__xor__(y) <==> x^y """ pass denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """ 分母 = 1 """ """the denominator of a rational number in lowest terms""" imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """ 虛數，無意義 """ """the imaginary part of a complex number""" numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """ 分子 = 數字大小 """ """the numerator of a rational number in lowest terms""" real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """ 實屬，無意義 """ """the real part of a complex number""" int
序列類型：
序列表示索引為非負整數的有序對象集合，包括字符串、列表和元組
字符串是字符的
列表和元組是任意python對象的序列
字符和元組屬於不可變序列，而列表則支持插入、刪除和替換元素等
所有序列都支持迭代
序列操作總結：(當然元組是不可變對象,對元素的操作是不支持的,當然了有嵌套列表字典是可以操作的)
- s + r 連接
- s * n 重復s的n次復制
- v1,v2...vn = s 變量解包(unpack)
- s[i] 索引
- s[i:j] 切片
- s[i:j:stride] 擴展切片
- x in s,x not in s 成員關系
- for x in s: 迭代
- all(s) 如果s中的所有項都為True，則返回True
- any(s) 如果s中的任意項為True，則返回True
- len(s) 長度,元素個數
- min(s) s中的最小項
- max(s) s中的最大項
- sum(s [,initial]) 具有可選初始值的項的和
- del s[i] 刪除一個元素
- del s[i:j] 刪除一個切片
- del s[i:j:stride] 刪除一個擴展切片
字符類型：不可變對象
字符串字面量：把文本放入單引號、雙引號或三引號中，python2.x默認不是國際字符集unicode，需要unicode定義時加上u,python3無需加
>>> str1 = u'hello world' >>> type(str1) unicode
文檔字串：模塊、類或函數的第一條語句是一個字符的話，該字符串就成為文檔字符串，可以使用__doc__屬性引用
>>> def printName(): 'test function' print('hello world') >>> printName.__doc__
適用於字符串常用方法：
str.capitalize() 將字符串的首字母變大寫
str.title() 將字符串中的每個單詞的首字母大寫
str.upper() 將字符串變成大寫
str.lower() 將字符串變成小寫
str.index() 找出索引對應的字符串
str.find() 同上
str.count() 找出字符串中元素出現的次數
str.format() 也是格式化的一種
str.center() 以什么字符從字符串兩邊填充
str.join() 以str為分隔符連接字符串
str.split() 以什么為分隔符分隔字符串
str.strip() 將字符串兩邊中的空格去掉
str.replace() 查找替換
str.isupper() 判斷是否為大寫
str.islower() 判斷是否為小寫
str.isalnum() 判斷是否是字母數字
str.isalpha() 判斷是否是字母下划線
str.isdigit() 判斷是否是數字
str.isspace() 判斷是否為空
str.startswith() 找出以什么為開頭的字符元素
str.endswith() 找出以什么為結尾的字符元素
附上源碼：
class str(basestring): """ str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object. """ def capitalize(self): """ 首字母變大寫 """ """ S.capitalize() -> string Return a copy of the string S with only its first character capitalized. """ return "" def center(self, width, fillchar=None): """ 內容居中，width：總長度；fillchar：空白處填充內容，默認無 """ """ S.center(width[, fillchar]) -> string Return S centered in a string of length width. Padding is done using the specified fill character (default is a space) """ return "" def count(self, sub, start=None, end=None): """ 子序列個數 """ """ S.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation. """ return 0 def decode(self, encoding=None, errors=None): """ 解碼 """ """ S.decode([encoding[,errors]]) -> object Decodes S using the codec registered for encoding. encoding defaults to the default encoding. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name registered with codecs.register_error that is able to handle UnicodeDecodeErrors. """ return object() def encode(self, encoding=None, errors=None): """ 編碼，針對unicode """ """ S.encode([encoding[,errors]]) -> object Encodes S using the codec registered for encoding. encoding defaults to the default encoding. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any other name registered with codecs.register_error that is able to handle UnicodeEncodeErrors. """ return object() def endswith(self, suffix, start=None, end=None): """ 是否以 xxx 結束 """ """ S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try. """ return False def expandtabs(self, tabsize=None): """ 將tab轉換成空格，默認一個tab轉換成8個空格 """ """ S.expandtabs([tabsize]) -> string Return a copy of S where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed. """ return "" def find(self, sub, start=None, end=None): """ 尋找子序列位置，如果沒找到，返回 -1 """ """ S.find(sub [,start [,end]]) -> int Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 0 def format(*args, **kwargs): # known special case of str.format """ 字符串格式化，動態參數，將函數式編程時細說 """ """ S.format(*args, **kwargs) -> string Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces ('{' and '}'). """ pass def index(self, sub, start=None, end=None): """ 子序列位置，如果沒找到，報錯 """ S.index(sub [,start [,end]]) -> int Like S.find() but raise ValueError when the substring is not found. """ return 0 def isalnum(self): """ 是否是字母和數字 """ """ S.isalnum() -> bool Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise. """ return False def isalpha(self): """ 是否是字母 """ """ S.isalpha() -> bool Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise. """ return False def isdigit(self): """ 是否是數字 """ """ S.isdigit() -> bool Return True if all characters in S are digits and there is at least one character in S, False otherwise. """ return False def islower(self): """ 是否小寫 """ """ S.islower() -> bool Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise. """ return False def isspace(self): """ S.isspace() -> bool Return True if all characters in S are whitespace and there is at least one character in S, False otherwise. """ return False def istitle(self): """ S.istitle() -> bool Return True if S is a titlecased string and there is at least one character in S, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise. """ return False def isupper(self): """ S.isupper() -> bool Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise. """ return False def join(self, iterable): """ 連接 """ """ S.join(iterable) -> string Return a string which is the concatenation of the strings in the iterable. The separator between elements is S. """ return "" def ljust(self, width, fillchar=None): """ 內容左對齊，右側填充 """ """ S.ljust(width[, fillchar]) -> string Return S left-justified in a string of length width. Padding is done using the specified fill character (default is a space). """ return "" def lower(self): """ 變小寫 """ """ S.lower() -> string Return a copy of the string S converted to lowercase. """ return "" def lstrip(self, chars=None): """ 移除左側空白 """ """ S.lstrip([chars]) -> string or unicode Return a copy of the string S with leading whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping """ return "" def partition(self, sep): """ 分割，前，中，后三部分 """ """ S.partition(sep) -> (head, sep, tail) Search for the separator sep in S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return S and two empty strings. """ pass def replace(self, old, new, count=None): """ 替換 """ """ S.replace(old, new[, count]) -> string Return a copy of string S with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced. """ return "" def rfind(self, sub, start=None, end=None): """ S.rfind(sub [,start [,end]]) -> int Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 0 def rindex(self, sub, start=None, end=None): """ S.rindex(sub [,start [,end]]) -> int Like S.rfind() but raise ValueError when the substring is not found. """ return 0 def rjust(self, width, fillchar=None): """ S.rjust(width[, fillchar]) -> string Return S right-justified in a string of length width. Padding is done using the specified fill character (default is a space) """ return "" def rpartition(self, sep): """ S.rpartition(sep) -> (head, sep, tail) Search for the separator sep in S, starting at the end of S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return two empty strings and S. """ pass def rsplit(self, sep=None, maxsplit=None): """ S.rsplit([sep [,maxsplit]]) -> list of strings Return a list of the words in the string S, using sep as the delimiter string, starting at the end of the string and working to the front. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator. """ return [] def rstrip(self, chars=None): """ S.rstrip([chars]) -> string or unicode Return a copy of the string S with trailing whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping """ return "" def split(self, sep=None, maxsplit=None): """ 分割， maxsplit最多分割幾次 """ """ S.split([sep [,maxsplit]]) -> list of strings Return a list of the words in the string S, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator and empty strings are removed from the result. """ return [] def splitlines(self, keepends=False): """ 根據換行分割 """ """ S.splitlines(keepends=False) -> list of strings Return a list of the lines in S, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true. """ return [] def startswith(self, prefix, start=None, end=None): """ 是否起始 """ """ S.startswith(prefix[, start[, end]]) -> bool Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try. """ return False def strip(self, chars=None): """ 移除兩段空白 """ """ S.strip([chars]) -> string or unicode Return a copy of the string S with leading and trailing whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping """ return "" def swapcase(self): """ 大寫變小寫，小寫變大寫 """ """ S.swapcase() -> string Return a copy of the string S with uppercase characters converted to lowercase and vice versa. """ return "" def title(self): """ S.title() -> string Return a titlecased version of S, i.e. words start with uppercase characters, all remaining cased characters have lowercase. """ return "" def translate(self, table, deletechars=None): """ 轉換，需要先做一個對應表，最后一個表示刪除字符集合 intab = "aeiou" outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!" print str.translate(trantab, 'xm') """ """ S.translate(table [,deletechars]) -> string Return a copy of the string S, where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a string of length 256 or None. If the table argument is None, no translation is applied and the operation simply removes the characters in deletechars. """ return "" def upper(self): """ S.upper() -> string Return a copy of the string S converted to uppercase. """ return "" def zfill(self, width): """方法返回指定長度的字符串，原字符串右對齊，前面填充0。""" """ S.zfill(width) -> string Pad a numeric string S with zeros on the left, to fill a field of the specified width. The string S is never truncated. """ return "" def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown pass def _formatter_parser(self, *args, **kwargs): # real signature unknown pass def __add__(self, y): """ x.__add__(y) <==> x+y """ pass def __contains__(self, y): """ x.__contains__(y) <==> y in x """ pass def __eq__(self, y): """ x.__eq__(y) <==> x==y """ pass def __format__(self, format_spec): """ S.__format__(format_spec) -> string Return a formatted version of S as described by format_spec. """ return "" def __getattribute__(self, name): """ x.__getattribute__('name') <==> x.name """ pass def __getitem__(self, y): """ x.__getitem__(y) <==> x[y] """ pass def __getnewargs__(self, *args, **kwargs): # real signature unknown pass def __getslice__(self, i, j): """ x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported. """ pass def __ge__(self, y): """ x.__ge__(y) <==> x>=y """ pass def __gt__(self, y): """ x.__gt__(y) <==> x>y """ pass def __hash__(self): """ x.__hash__() <==> hash(x) """ pass def __init__(self, string=''): # known special case of str.__init__ """ str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object. # (copied from class doc) """ pass def __len__(self): """ x.__len__() <==> len(x) """ pass def __le__(self, y): """ x.__le__(y) <==> x<=y """ pass def __lt__(self, y): """ x.__lt__(y) <==> x<y """ pass def __mod__(self, y): """ x.__mod__(y) <==> x%y """ pass def __mul__(self, n): """ x.__mul__(n) <==> x*n """ pass @staticmethod # known case of __new__ def __new__(S, *more): """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ pass def __ne__(self, y): """ x.__ne__(y) <==> x!=y """ pass def __repr__(self): """ x.__repr__() <==> repr(x) """ pass def __rmod__(self, y): """ x.__rmod__(y) <==> y%x """ pass def __rmul__(self, n): """ x.__rmul__(n) <==> n*x """ pass def __sizeof__(self): """ S.__sizeof__() -> size of S in memory, in bytes """ pass def __str__(self): """ x.__str__() <==> str(x) """ pass
列表類型：可變對象
表達式符號：[]
創建列表：
name_list = ['alex', 'seven', 'eric'] 或 name_list ＝ list(['alex', 'seven', 'eric'])
容器類型
任意對象的有序集合，通過索引訪問其中的元素，可變對象
異構混合類型，可以任意嵌套其它類型
支持在原處修改：
修改指定的索引元素，修改指定的分片，刪除語句，類的內置方法
適用於列表常用方法：
list.insert() 在列表中指定索引位置前插入元素 list.append() 在列表尾部插入 list.remove() 刪除指定的元素 list.pop() 沒有指定索引，則彈出最后一個元素，返回的結果是彈出的索引對應的元素 list.copy() 淺復制,只會復制第一層,如果有嵌套序列則不會復制,如果需要復制則要導入copy模塊 list.extend() 把另外一個列表合並，並不是追加 list.index() 列表中元素出現的索引位置 list.count() 統計列表中元素的次數 list.reverse() 進行逆序 list.sort() 進行排序,python3無法把數字和字符串一起排序 l1 + l2 : 合並兩個列表，返回一個新的列表，不會修改原列表 l1 * N : 把l1重復N次，返回一個新列表
附上源碼：
class list(object): """ list() -> new empty list list(iterable) -> new list initialized from iterable's items """ def append(self, p_object): # real signature unknown; restored from __doc__ """ L.append(object) -- append object to end """ pass def count(self, value): # real signature unknown; restored from __doc__ """ L.count(value) -> integer -- return number of occurrences of value """ return 0 def extend(self, iterable): # real signature unknown; restored from __doc__ """ L.extend(iterable) -- extend list by appending elements from the iterable """ pass def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ """ L.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """ return 0 def insert(self, index, p_object): # real signature unknown; restored from __doc__ """ L.insert(index, object) -- insert object before index """ pass def pop(self, index=None): # real signature unknown; restored from __doc__ """ L.pop([index]) -> item -- remove and return item at index (default last). Raises IndexError if list is empty or index is out of range. """ pass def remove(self, value): # real signature unknown; restored from __doc__ """ L.remove(value) -- remove first occurrence of value. Raises ValueError if the value is not present. """ pass def reverse(self): # real signature unknown; restored from __doc__ """ L.reverse() -- reverse *IN PLACE* """ pass def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__ """ L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1 """ pass def __add__(self, y): # real signature unknown; restored from __doc__ """ x.__add__(y) <==> x+y """ pass def __contains__(self, y): # real signature unknown; restored from __doc__ """ x.__contains__(y) <==> y in x """ pass def __delitem__(self, y): # real signature unknown; restored from __doc__ """ x.__delitem__(y) <==> del x[y] """ pass def __delslice__(self, i, j): # real signature unknown; restored from __doc__ """ x.__delslice__(i, j) <==> del x[i:j] Use of negative indices is not supported. """ pass def __eq__(self, y): # real signature unknown; restored from __doc__ """ x.__eq__(y) <==> x==y """ pass def __getattribute__(self, name): # real signature unknown; restored from __doc__ """ x.__getattribute__('name') <==> x.name """ pass def __getitem__(self, y): # real signature unknown; restored from __doc__ """ x.__getitem__(y) <==> x[y] """ pass def __getslice__(self, i, j): # real signature unknown; restored from __doc__ """ x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported. """ pass def __ge__(self, y): # real signature unknown; restored from __doc__ """ x.__ge__(y) <==> x>=y """ pass def __gt__(self, y): # real signature unknown; restored from __doc__ """ x.__gt__(y) <==> x>y """ pass def __iadd__(self, y): # real signature unknown; restored from __doc__ """ x.__iadd__(y) <==> x+=y """ pass def __imul__(self, y): # real signature unknown; restored from __doc__ """ x.__imul__(y) <==> x*=y """ pass def __init__(self, seq=()): # known special case of list.__init__ """ list() -> new empty list list(iterable) -> new list initialized from iterable's items # (copied from class doc) """ pass def __iter__(self): # real signature unknown; restored from __doc__ """ x.__iter__() <==> iter(x) """ pass def __len__(self): # real signature unknown; restored from __doc__ """ x.__len__() <==> len(x) """ pass def __le__(self, y): # real signature unknown; restored from __doc__ """ x.__le__(y) <==> x<=y """ pass def __lt__(self, y): # real signature unknown; restored from __doc__ """ x.__lt__(y) <==> x<y """ pass def __mul__(self, n): # real signature unknown; restored from __doc__ """ x.__mul__(n) <==> x*n """ pass @staticmethod # known case of __new__ def __new__(S, *more): # real signature unknown; restored from __doc__ """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ pass def __ne__(self, y): # real signature unknown; restored from __doc__ """ x.__ne__(y) <==> x!=y """ pass def __repr__(self): # real signature unknown; restored from __doc__ """ x.__repr__() <==> repr(x) """ pass def __reversed__(self): # real signature unknown; restored from __doc__ """ L.__reversed__() -- return a reverse iterator over the list """ pass def __rmul__(self, n): # real signature unknown; restored from __doc__ """ x.__rmul__(n) <==> n*x """ pass def __setitem__(self, i, y): # real signature unknown; restored from __doc__ """ x.__setitem__(i, y) <==> x[i]=y """ pass def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__ """ x.__setslice__(i, j, y) <==> x[i:j]=y Use of negative indices is not supported. """ pass def __sizeof__(self): # real signature unknown; restored from __doc__ """ L.__sizeof__() -- size of L in memory, in bytes """ pass __hash__ = None
#通過索引來修改元素
>>> print(l2) [1, 2, 3, 4, 5] >>> l2[1] = 32 >>> print(l2) [1, 32, 3, 4, 5] >>> l2[3] = 'xyz' >>> print(l2) [1, 32, 3, 'xyz', 5] >>> print(l1) [1, 2, 3] >>> l1[1:] = ['m','n','r'] >>> print(l1) [1,'m','n','r']
#通過分片進行刪除
>>> l2[1:3] [32, 3] >>> l2[1:3] = [] >>> print(l2) [1, 'xyz', 5]
#通過內置的函數進行刪除
>>> del(l2[1:]) >>> print(l2) [1]
#通過列表類中的方法進行增刪改
>>> l3 = [1,2,3,4,5,6] >>> l3.append(77) >>> print(l3) [1, 2, 3, 4, 5, 6, 77] >>> l4 = ['x','y','z'] >>> l3.append(l4) >>> print(l3) [1, 2, 3, 4, 5, 6, 77, ['x', 'y', 'z']]
#變量解包
>>> l1,l2 = [[1,'x','y'],[2,'z','r']] >>> print(l1) [1, 'x', 'y'] >>> type(l1) >>> print(l2) [2, 'z', 'r']
#找到列表中的元素並修改
tomcat@node:~/scripts$ cat b.py name = [1,2,3,4,5,1,5,6] if 1 in name: num_of_ele = name.count(1) position_of_ele = name.index(1) name[position_of_ele] = 888 print(name) tomcat@node:~/scripts$ python b.py [888, 2, 3, 4, 5, 1, 5, 6]
#找到列表中的元素並批量修改
tomcat@node:~/scripts$ cat b.py name = [1,2,3,4,5,1,5,6] for i in range(name.count(1)): ele_index = name.index(1) name[ele_index] = 8888888 print(name) tomcat@node:~/scripts$ python b.py [8888888, 2, 3, 4, 5, 8888888, 5, 6]
元組類型：不可變對象
表達式符號：()
創建元組：
ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
容器類型
任意對象的有序集合，通過索引訪問其中的元素，不可變對象
異構混合類型，可以任意嵌套其它類型
雖然元組本身不可變，但如果元組內嵌套了可變類型的元素，那么此類元素的修改不會返回新元組
(): 空元組
(1,): 單個元組需要尾部加上逗號，如果元素是數字沒有加逗號則不是元組
(1,2): 多元素元組
1,2,3,4: 在定義變量時沒有加上小括號，默認是元組，最好不建議使用
適用於元組常用方法：
tuple.count() 統計元組中元素的個數
tuple.index() 找出元組中元素的索引位置
#在沒有嵌套的情況，元組是不可變對象，但是在嵌套了列表，列表是可變的
>>> t5 = ('x',[1,2,3,4]) >>> print t5 ('x', [1, 2, 3, 4]) >>> t5[1].pop() 4 >>> print(t5) ('x', [1, 2, 3])
#元組解包
>>> t1,t2 = ((1,2,3,4,5,'xy'),('s','y','w')) >>> print(t1) (1, 2, 3, 4, 5, 'xy') >>> type(t1) tuple >>> print(t2) ('s', 'y', 'w')
字典類型：dict 可變對象
表達式符號：{}
創建字典：
person = {"name": "tomcat", 'age': 18}
或
person = dict({"name": "tomcat", 'age': 18})
字典在其他編程語言中又稱作關聯數組或散列表
通過鍵(key)實現元素存取，無序的，可變類型容器，長度可變，異構，嵌套
{}: 空字典
{'x':32,'y':[1,2,3,4]}
兩種遍歷字典方法：
第一種： for k,v in dict.items(): print(k,v) 第二種：高效 for key in dict: print(key,dict[key])
適用於字典常用方法：
dict.get(key) 取得某個key的value dict.has_key(key) 判斷字典是否有這個key,在python3中已經廢除,使用in 判斷 dict.keys() 返回所有的key為一個列表 dict.values() 返回所有的value為一個列表 dict.items() 將字典的鍵值拆成元組，全部元組組成一個列表 dict.pop(key) 彈出某個key-value dict.popitem() 隨機彈出key-value dict.clear() 清除字典中所有元素 dict.copy() 字典復制，d2 = d1.copy(),是淺復制,如果深復制需要copy模塊 dict.fromkeys(S) 生成一個新字典 dict.update(key) 將一個字典合並到當前字典中 dict.iteritems() 生成key-value迭代器，可以用next()取下個key-value dict.iterkeys() 生成key迭代器 dict.itervalues() 生成values迭代器
附上源碼：
class dict(object): """ dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) """ def clear(self): # real signature unknown; restored from __doc__ """ 清除內容 """ """ D.clear() -> None. Remove all items from D. """ pass def copy(self): # real signature unknown; restored from __doc__ """ 淺拷貝 """ """ D.copy() -> a shallow copy of D """ pass @staticmethod # known case def fromkeys(S, v=None): # real signature unknown; restored from __doc__ """ dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. v defaults to None. """ pass def get(self, k, d=None): # real signature unknown; restored from __doc__ """ 根據key獲取值，d是默認值 """ """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ pass def has_key(self, k): # real signature unknown; restored from __doc__ """ 是否有key """ """ D.has_key(k) -> True if D has a key k, else False """ return False def items(self): # real signature unknown; restored from __doc__ """ 所有項的列表形式 """ """ D.items() -> list of D's (key, value) pairs, as 2-tuples """ return [] def iteritems(self): # real signature unknown; restored from __doc__ """ 項可迭代 """ """ D.iteritems() -> an iterator over the (key, value) items of D """ pass def iterkeys(self): # real signature unknown; restored from __doc__ """ key可迭代 """ """ D.iterkeys() -> an iterator over the keys of D """ pass def itervalues(self): # real signature unknown; restored from __doc__ """ value可迭代 """ """ D.itervalues() -> an iterator over the values of D """ pass def keys(self): # real signature unknown; restored from __doc__ """ 所有的key列表 """ """ D.keys() -> list of D's keys """ return [] def pop(self, k, d=None): # real signature unknown; restored from __doc__ """ 獲取並在字典中移除 """ """ D.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised """ pass def popitem(self): # real signature unknown; restored from __doc__ """ 獲取並在字典中移除 """ """ D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty. """ pass def setdefault(self, k, d=None): # real signature unknown; restored from __doc__ """ 如果key不存在，則創建，如果存在，則返回已存在的值且不修改 """ """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ pass def update(self, E=None, **F): # known special case of dict.update """ 更新 {'name':'alex', 'age': 18000} [('name','sbsbsb'),] """ """ D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k] """ pass def values(self): # real signature unknown; restored from __doc__ """ 所有的值 """ """ D.values() -> list of D's values """ return [] def viewitems(self): # real signature unknown; restored from __doc__ """ 所有項，只是將內容保存至view對象中 """ """ D.viewitems() -> a set-like object providing a view on D's items """ pass def viewkeys(self): # real signature unknown; restored from __doc__ """ D.viewkeys() -> a set-like object providing a view on D's keys """ pass def viewvalues(self): # real signature unknown; restored from __doc__ """ D.viewvalues() -> an object providing a view on D's values """ pass def __cmp__(self, y): # real signature unknown; restored from __doc__ """ x.__cmp__(y) <==> cmp(x,y) """ pass def __contains__(self, k): # real signature unknown; restored from __doc__ """ D.__contains__(k) -> True if D has a key k, else False """ return False def __delitem__(self, y): # real signature unknown; restored from __doc__ """ x.__delitem__(y) <==> del x[y] """ pass def __eq__(self, y): # real signature unknown; restored from __doc__ """ x.__eq__(y) <==> x==y """ pass def __getattribute__(self, name): # real signature unknown; restored from __doc__ """ x.__getattribute__('name') <==> x.name """ pass def __getitem__(self, y): # real signature unknown; restored from __doc__ """ x.__getitem__(y) <==> x[y] """ pass def __ge__(self, y): # real signature unknown; restored from __doc__ """ x.__ge__(y) <==> x>=y """ pass def __gt__(self, y): # real signature unknown; restored from __doc__ """ x.__gt__(y) <==> x>y """ pass def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ """ dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) # (copied from class doc) """ pass def __iter__(self): # real signature unknown; restored from __doc__ """ x.__iter__() <==> iter(x) """ pass def __len__(self): # real signature unknown; restored from __doc__ """ x.__len__() <==> len(x) """ pass def __le__(self, y): # real signature unknown; restored from __doc__ """ x.__le__(y) <==> x<=y """ pass def __lt__(self, y): # real signature unknown; restored from __doc__ """ x.__lt__(y) <==> x<y """ pass @staticmethod # known case of __new__ def __new__(S, *more): # real signature unknown; restored from __doc__ """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ pass def __ne__(self, y): # real signature unknown; restored from __doc__ """ x.__ne__(y) <==> x!=y """ pass def __repr__(self): # real signature unknown; restored from __doc__ """ x.__repr__() <==> repr(x) """ pass def __setitem__(self, i, y): # real signature unknown; restored from __doc__ """ x.__setitem__(i, y) <==> x[i]=y """ pass def __sizeof__(self): # real signature unknown; restored from __doc__ """ D.__sizeof__() -> size of D in memory, in bytes """ pass __hash__ = None dict
#字典也支持索引的方式獲取,只不過key是他的索引了
>>> d1 = {'x':32,'y':[1,2,3,4]}
>>> d1['x']
32
>>> d1['y']
[1, 2, 3, 4]
>>> d1['y'][3:]
[4]
>>> len(d1)
2
#變量解包1
>>> d1.items() [('y', [1, 2, 3, 4]), ('x', 32)] >>> t1,t2 = d1.items() >>> print(t1) ('y', [1, 2, 3, 4]) >>> print(t2) ('x', 32)
#變量解包2
>>> d3,d4 = {'x':32,'y':80}
>>> print(d3)
y
>>> print(d4)
x
#合並字典，但是在有相同的key時會覆蓋原有的key的值
>>> d1 = {'x':1,'y':2}
>>> d2 = {'m':21,'n':76,'y':44}
>>> d1.update(d2)
>>> print(d1)
{'y': 44, 'x': 1, 'm': 21, 'n': 76}
集合類型：set()可變對象,frozenset()不可變對象
表達式符號：{}
創建集合：
s = {"tom","cat","name","error"}
或
s = set({"tom","cat","name","error"})
集合是一組無序排序的可哈希hash的值,不重復
支持集合關系測試:
支持成員關系測試：in , not in
支持迭代
不支持：索引、元素獲取、切片
{"a",123,"b"}或者set()空集合
沒有特定語法格式，只能通過工廠函數創建set，像字符串則直接創建即可
set集合必須中的元素必須是可迭代對象,所有元素不會重復,不像list列表是可以重復
集合運算符：
s | t s和t的並集 s & t s和t的交集 s - t 求差集 s ^ t 求對稱差集 len(s) 集合中項數 max(s) 最大值 min(s) 最小值
適用於可變集合常用方法：
s.add(item) 將item添加到s中。如果item已經在s中，則無任何效果
s.remove(item) 從s中刪除item。如果item不是s的成員，則引發KeyError異常
s.discard(item) 從s中刪除item.如果item不是s的成員，則無任何效果
s.pop() 隨機刪除一個任意集合元素，並將其從s刪除,如果有變量接收則會接收到刪除到的那個元素
s.clear() 刪除s中的所有元素
s.copy() 淺復制
s.update(t) 將t中的所有元素添加到s中。t可以是另一個集合、一個序列或者支持迭代的任意對象
s.union(t) 求並集。返回所有在s和t中的元素
s.intersection(t) 求交集。返回所有同時在s和t中的都有的元素
s.intersection_update(t) 計算s與t的交集，並將結果放入s
s.difference(t) 求差集。返回所有在set中，但不在t中的元素
s.difference_update(t) 從s中刪除同時也在t中的所有元素
s.symmetric_difference(t) 求對稱差集。返回所有s中沒有t中的元素和t中沒有s中的元素組成的集合
s.sysmmetric_difference_update(t) 計算s與t的對稱差集，並將結果放入s
s.isdisjoint(t) 如果s和t沒有相同項，則返回True
s.issubset(t) 如果s是t的一個子集，則返回True
s.issuperset(t) 如果s是t的一個超集，則返回True
附上源碼：
class set(object): """ set() -> new empty set object set(iterable) -> new set object Build an unordered collection of unique elements. """ def add(self, *args, **kwargs): # real signature unknown """ Add an element to a set，添加元素 This has no effect if the element is already present. """ pass def clear(self, *args, **kwargs): # real signature unknown """ Remove all elements from this set. 清除內容""" pass def copy(self, *args, **kwargs): # real signature unknown """ Return a shallow copy of a set. 淺拷貝 """ pass def difference(self, *args, **kwargs): # real signature unknown """ Return the difference of two or more sets as a new set. A中存在，B中不存在 (i.e. all elements that are in this set but not the others.) """ pass def difference_update(self, *args, **kwargs): # real signature unknown """ Remove all elements of another set from this set. 從當前集合中刪除和B中相同的元素""" pass def discard(self, *args, **kwargs): # real signature unknown """ Remove an element from a set if it is a member. If the element is not a member, do nothing. 移除指定元素，不存在不保錯 """ pass def intersection(self, *args, **kwargs): # real signature unknown """ Return the intersection of two sets as a new set. 交集 (i.e. all elements that are in both sets.) """ pass def intersection_update(self, *args, **kwargs): # real signature unknown """ Update a set with the intersection of itself and another. 取交集並更更新到A中 """ pass def isdisjoint(self, *args, **kwargs): # real signature unknown """ Return True if two sets have a null intersection. 如果沒有交集，返回True，否則返回False""" pass def issubset(self, *args, **kwargs): # real signature unknown """ Report whether another set contains this set. 是否是子序列""" pass def issuperset(self, *args, **kwargs): # real signature unknown """ Report whether this set contains another set. 是否是父序列""" pass def pop(self, *args, **kwargs): # real signature unknown """ Remove and return an arbitrary set element. Raises KeyError if the set is empty. 移除元素 """ pass def remove(self, *args, **kwargs): # real signature unknown """ Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError. 移除指定元素，不存在保錯 """ pass def symmetric_difference(self, *args, **kwargs): # real signature unknown """ Return the symmetric difference of two sets as a new set. 對稱差集 (i.e. all elements that are in exactly one of the sets.) """ pass def symmetric_difference_update(self, *args, **kwargs): # real signature unknown """ Update a set with the symmetric difference of itself and another. 對稱差集，並更新到a中 """ pass def union(self, *args, **kwargs): # real signature unknown """ Return the union of sets as a new set. 並集 (i.e. all elements that are in either set.) """ pass def update(self, *args, **kwargs): # real signature unknown """ Update a set with the union of itself and others. 更新 """ pass
不可變集合：
help(frozenset)
練習：尋找差異
# 數據庫中原有 old_dict = { "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 } } # cmdb 新匯報的數據 new_dict = { "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 }, "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 } } old_set=set(old_dict) new_set=set(new_dict) del_set=old_set.difference(new_set) add_set=new_set.difference(old_set) flush_set=old_set.intersection(new_set) for i in del_set: old_dict.pop(i) for i in add_set: old_dict[i]=new_dict[i] for i in flush_set: old_dict[i] = new_dict[i] print(old_dict)
# 數據庫中原有 old_dict = { "#1":8, "#2":4, "#3":2, } # cmdb 新匯報的數據 new_dict = { "#1":4, "#3":4, "#4":2, } old_set = set(old_dict.keys()) print(old_set) new_set = set(new_dict.keys()) print(new_set) remove_set = old_set.difference(new_set) print(remove_set) add_set = new_set.difference(old_set) print(add_set) update_set = old_set.intersection(new_set) print(update_set)
深拷貝淺拷貝
拷貝意味着對數據重新復制一份，對於拷貝有兩種深拷貝，淺拷貝兩種拷貝，不同的拷貝有不同的效果。拷貝操作對於基本數據結構需要分兩類進行考慮，一類是字符串和數字，另一類是列表、字典等。如果要進行拷貝的操作話，要import copy。
1、數字和字符串
對於數字和字符串而言，深拷貝，淺拷貝沒有什么區別，因為對於數字數字和字符串一旦創建便不能被修改，假如對於字符串進行替代操作，只會在內存中重新生產一個字符串，而對於原字符串，並沒有改變，基於這點，深拷貝和淺拷貝對於數字和字符串沒有什么區別，下面從代碼里面說明這一點。
import copy s='abc' print(s.replace('c','222')) # 打印出 ab222 print(s) # s='abc' s並沒有被修改 s1=copy.deepcopy(s) s2=copy.copy(s) #可以看出下面的值和地址都一樣，所以對於字符串和數字，深淺拷貝不一樣，數字和字符串一樣就不演示了，大家可以去試一下 print(s,id(s2)) # abc 1995006649768 print(s1,id(s2)) # abc 1995006649768 print(s2,id(s2)) # abc 1995006649768
2、字典、列表等數據結構
對於字典、列表等數據結構，深拷貝和淺拷貝有區別，從字面上來說，可以看出深拷貝可以完全拷貝，淺拷貝則沒有完全拷貝，下面先從內存地址分別來說明，假設 n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}。
淺拷貝在內存中只額外創建第一層數據 深拷貝在內存中將所有的數據重新創建一份
下面從代碼上來進行說明，copy.copy()與list.copy(),dict.copy()都屬於淺復制
import copy n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n2=copy.copy(n1) # 淺拷貝 n3=copy.deepcopy(n1) # 深拷貝 print(n1,id(n1),id(n1['k1']),id(n1['k3'])) print(n2,id(n2),id(n2['k1']),id(n2['k3'])) print(n3,id(n3),id(n3['k1']),id(n3['k3'])) # 從下面打印的值結合上面的圖就可以很好的理解， # {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713748822024 2713753080528 2713755115656 # {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713755121416 2713753080528 2713755115656 # {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713753267656 2713753080528 2713754905800
補充
一 、enumrate
為一個可迭代的對象添加序號，可迭代的對象你可以理解成能用for循環的就是可迭代的。默認是編號是從0開始，可以設置從1開始
li = ["手機", "電腦", '鼠標墊', '游艇'] for k, i in enumerate(li，1): print(k,i) 1 手機 2 電腦 3 鼠標墊 4 游艇
二、range和xrange
在python2中有xrange和range，其中range會一次在內存中開辟出了所需的所有資源，而xrange則是在for循環中循環一次則開辟一次所需的內存，而在Python3中沒有xrange，只有range ，但是python3的range代表的就是xrange。range用來指定范圍，生成指定的數字。
for i in range(10): #循環輸出所生成的 0-9 print(i) for i in range(1,10,2): #輸出所生成的 1 3 5 7 9 print(i)
練習：
一、元素分類
有如下值集合 [11,22,33,44,55,66,77,88,99]，將所有大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。即： {'k1': 大於66的所有值, 'k2': 小於66的所有值}
l= [11,22,33,44,55,66,77,88,99] bignum=[] smallnum=[] dir={} for num in l: if num>66: bignum.append(num) if num<66: smallnum.append(num) else: pass dir['k1']=bignum dir['k2']=smallnum print(dir)
二、查找
查找元素，移動空格，並查找以 a或A開頭 並且以 c 結尾的所有元素。
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
li = ["alec", " aric", "Alex", "Tony", "rain"] tu = ("alec", " aric", "Alex", "Tony", "rain") dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"} for i in li: if i.strip().capitalize().startswith('A') and i.strip().endswith('c'): print(i) for i in tu: if i.strip().capitalize().startswith('A') and i.strip().endswith('c'): print(i) for i in dic.values(): if i.strip().capitalize().startswith('A') and i.strip().endswith('c'): print (i)
三、輸出商品列表，用戶輸入序號，顯示用戶選中的商品
商品 li = ["手機", "電腦", '鼠標墊', '游艇']
#方法一 l1=[1,2,3,4] l2=["手機", "電腦", '鼠標墊', '游艇'] d=dict(zip(l1,l2)) print(d) num=input("請輸入商品編號：") print("你選擇的商品為 %s" %d[int(num)]) #方法二 li = ["手機", "電腦", '鼠標墊', '游艇'] for k, i in enumerate(li): print(k,i) k=input("請輸入商品編號：") print("你選擇的商品為 %s" % li[int(k)])
#!/usr/bin/env python # -*- coding:utf-8 -*- #!/usr/bin/env python # -*- coding:utf-8 -*- # Author:Alex Li salary = input("Input your salary:") if salary.isdigit(): salary = int(salary) else: exit("Invaild data type...") welcome_msg = 'Welcome to Alex Shopping mall'.center(50,'-') print(welcome_msg) exit_flag = False product_list = [ ('Iphone',5888), ('Mac Air',8000), ('Mac Pro',9000), ('XiaoMi 2',19.9), ('Coffee',30), ('Tesla',820000), ('Bike',700), ('Cloth',200),] shop_car = [] while exit_flag is not True: #for product_item in product_list: # p_name,p_price = product_item print("product list".center(50,'-')) for item in enumerate(product_list): index = item[0] p_name = item[1][0] p_price = item[1][1] print(index,'.',p_name,p_price) user_choice = input("[q=quit,c=check]What do you want to buy?:") if user_choice.isdigit():#肯定是選擇shangpin user_choice = int(user_choice) if user_choice < len(product_list): p_item = product_list[user_choice] if p_item[1] <= salary: #買的起 shop_car.append(p_item) #放入購物車 salary -= p_item[1] #減錢 print("Added [%s] into shop car,you current balance is \033[31;1m[%s]\033[0m" % (p_item,salary)) else: print("Your balance is [%s],cannot afford this.." % salary) else: if user_choice == 'q' or user_choice =='quit': print("purchased products as below".center(40,'*')) for item in shop_car: print(item) print("END".center(40,'*')) print("Your balance is [%s]" % salary) print("Bye") exit_flag = True elif user_choice == 'c' or user_choice =='check': print("purchased products as below".center(40,'*')) for item in shop_car: print(item) print("END".center(40,'*')) print("Your balance is \033[41;1m[%s]\033[0m" % salary)
四、購物車
功能要求：
- 要求用戶輸入總資產，例如：2000
- 顯示商品列表，讓用戶根據序號選擇商品，加入購物車
- 購買，如果商品總額大於總資產，提示賬戶余額不足，否則，購買成功。
product = [
("iphone",5800),
("watch",380),
("bike",800),
("book",120),
("computer",4000)
]
shopping_car = []
salary = input("input your salary: ")
if salary.isdigit():
salary = int(salary)
while True:
for i in enumerate(product):
print(i)
user_choice = input(">>>或者q:")
if user_choice.isdigit():
user_choice = int(user_choice)
if user_choice >= 0 and user_choice < len(product):
p_item = product[user_choice]
if salary >= p_item[1]:
shopping_car.append(p_item[0])
salary -= p_item[1]
print("你購買了\033[32m%s\033[0m,你的余額剩余\033[31m%s\033[0m" % (p_item[0], salary))
else:
print("\033[31m你的余額不足\033[0m")
else:
print("你輸入的項目[%s]不存在,請重新輸入" % user_choice)
elif user_choice == 'q':
print("你購買了這些商品:".center(30,"-"))
for i in shopping_car:
print("\033[32m%s\033[0m" %i)
print("\033[31m余額%s\033[0m" %salary)
exit()
else:
print("你輸入的[%s]不存在" % user_choice)
else:
print("你輸入的金額不正確！請重新輸入金額！")
五、用戶交互，顯示省市縣三級聯動的選擇
dic = { "河北": { "石家庄": ["鹿泉", "藁城", "元氏"], "邯鄲": ["永年", "涉縣", "磁縣"], }, "湖南": { "長沙":['a','b','c'], "株洲":['d','e','f'] }, "湖北": { "武漢":['g','h','i'], "黃石":['j','k','l'] } } for k in dic.keys(): print(k) flag=True while flag: n=input("請輸入你所在省：") for k in dic.keys(): if n in dic.keys(): if k == n: for i in dic[n].keys(): print(i) w = input("請輸入你所在的城市：") for i in dic[n].keys(): if w in dic[n].keys(): if i == w: for k in dic[n][w]: print(k) s=input("請輸入你所在的縣：") for j in dic[n][w]: if s in dic[n][w]: if j==s: print("你所在的位置是：%s省%s市%s縣" % (n,w,s)) flag = False break else: print('不存在，請重新輸入') break else: print('不存在，請重新輸入') break else: print('不存在，請重新輸入') break