oldboy2-5 运算，数据类型，作业
一、基本数据类型
1、数字（int）
32位系统，整数位数为32位，取值范围为-2**31~2**31-1
64位系统，整数位数为64位，取值范围为-2**63~2**63-1
(1)bit_length(self)计算表该数字转换为二进制的长度
1 b=bin(10)#将十进制10转换成二进制，并赋值给b 2 print(b)#将b印出来 3 a=10#将十进制10赋值给a 4 print (a.bit_length())#通过int自带的内置函数，计算数字a的二级制长度并打印
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) 4 """ def bit_length(self): """ 返回表示该数字的时占用的最少位数 """ """ int.bit_length() -> int Number of bits necessary to represent self in binary. >>> bin(37) '0b100101' >>> (37).bit_length() 6 """ 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) 4 # (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"""
2、布尔值（非真即假）
布尔值就两个0,1 0代表假，1代表真
3、字符串
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
（1）capitalize首字母大写
格式：capitalize(self)
1 a="aaaaa"#生成一个字符串并将其赋值给a 2 b=a.capitalize()#把字符串的首字母大写 3 print (b)#打印字符串
(2)center字符串内容居中
格式：center(self,width,fillchar=None)
参数说明：width字符串的总长度;fillchar空白处填充的内容,参数fillchar的默认参数是None表示无填充内容（如果居中前后字符不一样多，会把多的那个放在后面）
1 a="aaa" #生成一个字符串并将其赋值给a 2 b=a.center(10,"b") #字符居串居中，长度为10，空白处填充内容为b 3 print(b)#打印b
（3）count字符串中指定字符的总个数
格式：count(self,sub,start=None,end=None)
参数说明：sub:指定的字符，start开始位置，默认值从头开始，end指定结束位置，默认是字符串结尾
1 a="bbbaaacca"#生成一个字符串并将其赋值给a 2 b=a.count("a",3,5)#字符串a,从第4位到第6位（包括第4位，不包括第6位）a出现的次数 3 print(b)#打印b
（4）endswith判断字符串是否以指定字符结束，如果是返回True否则返回False
格式：endswith(self,suffix,start=None,end=None)
参数说明：suff 指定结束的字符串，start开始位置，默认值从头开始，end指定结束位置，默认是字符串结尾
a="bbbaaacca"#生成一个字符串并将其赋值给a b=a.endswith("c",2,7)#字符串a,从第3位到第8位（包括第3位，不包括第8位）以c结尾 print(b)#打印b
（5）expandtabs将tab转换成空格，默认一个tab转换成8个空格
格式：expandtabs(self,tabsize=None)
参数说明:tabsize 将tab转换成空格的个数，默认是8个
a = "bbb\tcca" # 生成一个字符串并将其赋值给a b=a.expandtabs(10)#将字符串a中的tab转换成10个空格 print(b)#打印b
（7）find 查找字符串中指定字符的位置（从左往右查找，找到第一个就停止），并返回该指定字符的索引，如果没有返回-1
格式：find(self,sub,start=None,end=None)
参数说明：sub指定要查找的字符串，start开始位置，默认值从头开始，end指定结束位置，默认是字符串结尾
a = "bbbaaacca" # 生成一个字符串并将其赋值给a b = a.find("c", 2, 6)#查找字符串a中c的位置，从第3位到第7位（包括第3位，不包括第7位） print(b)#打印b
（8）index 查找字符串中指定字符的位置（从左往右查找，找到第一个就停止），并返回该指定字符的索引，如果没有报错
index(self,sub,start=None,end=None)
参数说明：sub指定要查找的字符串，start开始位置，默认值从头开始，end指定结束位置，默认是字符串结尾
a = "bbbaaacca" # 生成一个字符串并将其赋值给a b = a.index("c", 2, 6)#查找字符串a中c的位置，从第3位到第7位（包括第3位，不包括第7位） print(b)#打印b
（9）isalnum 判断字符串是否全是字母或数字，如果是返回True否则返回False
a = "bbbaaa....ca" # 生成一个字符串并将其赋值给a b = a.isalnum() # 判断字符串是否全是字母或数字 print(b) # 打印b
（10）isalpha 判断字符串是否全是字母，如果是返回True否则返回False
a = "bbbaa1ca" # 生成一个字符串并将其赋值给a b = a.isalpha() # 判断字符串是否全是字母 print(b) # 打印b
(11)isdigit 判断字符串是否全是数字，如果是返回True否则返回False
a = "11111111" # 生成一个字符串并将其赋值给a b = a.isdigit() # 判断字符串是否全是数字 print(b) # 打印b
（12）islower判断字符串是否全是小写的
a = "bbaaacc11a" # 生成一个字符串并将其赋值给a b = a.islower() # 判断字符串是否全是小写 print(b) # 打印b
（13）isspace判断字符串是否全是字符串
（14）istitle判断是否是标题
（15）isupper判断字符串是否都是大写
a = "A11AA" # 生成一个字符串并将其赋值给a b = a.isupper() # 判断字符串是否全是大写 print(b) # 打印b
（16）join连接，将参数的每个字符串分别加到原字符串的前面，新生成的字符串再相加
a = "A11AA" # 生成一个字符串并将其赋值给a b = a.join("cc") # 将每一个c都加到a字符串最前面，新生成的两个字符串再相加 print(b) # 打印b
（17）ljust左对齐，右侧填充
格式：ljust(self,width,fillchar=None)
参数说明：width 字符串的长度，fillchar=None右侧填充物为空
a = "A11AA" # 生成一个字符串并将其赋值给a b = a.ljust(10,"a") # 字符串长度为10，右侧用a来填充 print(b) # 打印b
（18）lstrip移除左侧空白
a = " A11AA" # 生成一个字符串并将其赋值给a b = a.lstrip() # 删除字符串a左侧空格 print(b) # 打印b
（19）replace查找并替换字符中的字符
格式：replace(self,old,new,count=None)
参数说明：old字符串中需要替换的值，new字符串中需要替换成的新值,count=None默认是全部替换
a = "bbbAaa1ccA" # 生成一个字符串并将其赋值给a b = a.replace("b","d",2) # 将字符串中的b替换成d，，只替换2个 print(b) # 打印b
（20）rfind反向查找，用法find相同
（21）rindex反向查找，与index用法相同
（22）rstrip移除右侧空白，与strip用法相同
（23）strip移除两边空白
（24）startswith判断是否以指定字符开始，用法与endswith一样
（25）swapcase字符串大小写呼唤
a = "bbbAaa1ccA" # 生成一个字符串并将其赋值给a b = a.swapcase() # 将字符串大小写互换 print(b) # 打印b
（26）upper字符串全部转换成大写
a = "bbbAaa1ccA" # 生成一个字符串并将其赋值给a b = a.upper() # 将字符转换成大写 print(b) # 打印b
（27）zfill返回固定长度的字符串，原字符串右对齐，左边填充0
a = "bbbAaa1ccA" # 生成一个字符串并将其赋值给a b = a.zfill(20) # 字符串长度为20，左侧填充0 print(b) # 打印b
4、元组
（1）count元组中指定元素出现的次数
a = ("a", "b", "c", "d") # 元组a b = a.count("a")#"a"出现在元组a中的次数 print(b)#打印b
（2）index查找元组中指定元素的位置（从左往右查找，找到第一个就停止），并返回该指定字符的索引，如果没有报错
格式：index(self,value,start=None,end=None)
a = ("a", "b", "c", "d") # 元组a b = a.index("b",1,3)#"a"出现在元组第2个到第4个直接是否有"b" print(b)#打印b
列表
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
5、字典
（1）clear清除内容
a={"b":111,"c":"练习"}#字典a
b=a.clear()#清除a
（2）copy拷贝
a={"垃圾":111,"c":"练习"}
b=a.copy()
print(b)
(3)get根据key去取值
格式：get(self,k,d=None)
参数：k 判断k是否在key中，如果在根据k取值，如果不在返回d的值，默认是None
a = {"b": 111, "c": "练习"} # 字典a
b = (a.get("h", 2)) # 字典的key中有h的话返回h的值，没有h返回2
print(b) # 打印b
（4）has_key 3.0去掉了 =in 判断字典是否存在某一key值
（5）items将key和对应的value组成元组，存在列表中
1 a = {"b": 111, "c": "练习"} # 字典a 2 b = a.items() #将key和对应的value组成元组，存在列表中 3 print(b) # 打印b
（6）keys所有key的列表
a = {"b": 111, "c": "练习"}
print(a.keys())
（7）pop获取并在字典中删除
格式：pop.(self,k,d=None)
参数说明：k 判断keys中是否存在k 如果存在删除字典中的k 如果不存在则默认返回None
a = {"b": 111, "c": "练习"}#字典a
b=a.pop("d",2)#因为keys中不存在"d",所以返回2
print(b)
（8）setdefault(self,k,d=None)
如果k不存在，则创建，如果存在，则返回已经存在的值不修改
a = {"b": 111, "c": "练习"}#字典a
b=a.setdefault("d","aaaaa")#比较"d"在不在keys中，在的话返回原来的值不锈钢，不存在就创建新的key值
print(a)
（9）values
格式：所有的值
a = {"b": 111, "c": "练习"}#字典a
b=a.values()#将所有的字典的values值放入一个列表中
print(b)
（10）updat 将两个字典合并
a = {"b": 111, "c": "练习"}#字典a
b = {"d": 111, "c": "22"}#字典b
a.update(b)#将字典a,b合并
print(a)
元组
lass tuple(object): """ tuple() -> empty tuple tuple(iterable) -> tuple initialized from iterable's items If the argument is a tuple, the return value is the same object. """ def count(self, value): # real signature unknown; restored from __doc__ """ T.count(value) -> integer -- return number of occurrences of value """ return 0 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ """ T.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """ return 0 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 __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 __getnewargs__(self, *args, **kwargs): # real signature unknown 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 __hash__(self): # real signature unknown; restored from __doc__ """ x.__hash__() <==> hash(x) """ pass def __init__(self, seq=()): # known special case of tuple.__init__ """ tuple() -> empty tuple tuple(iterable) -> tuple initialized from iterable's items If the argument is a tuple, the return value is the same object. # (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 __rmul__(self, n): # real signature unknown; restored from __doc__ """ x.__rmul__(n) <==> n*x """ pass def __sizeof__(self): # real signature unknown; restored from __doc__ """ T.__sizeof__() -- size of T in memory, in bytes """ pass
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
6、range按照一定循环可迭代对象
格式：range(start=None, stop=None, step=None)
参数说明：start开始数字，默认从0开始，stop结束数字，默认不包含stop，step中间断几个显示
其他：range在2.x中会先执行存在在内存中，xrange在用的时候才执行，在3.x版本中range在用的时候才去执行
for i in range(1,10,3): print(i)
7、enumrate 为可迭代对象添加序号
li = ["手机", "电脑", '鼠标垫', '游艇'] while True: for k,v in enumerate(li,1): print(k,v) a =input("请输入序列号：") print(li[int(a) - 1])
8、for循环按照顺序迭代可迭代对象的内容
break可以跳出for循环
continue跳出本次循环，进行下一次循环
for i in range(10): if i == 7: continue if i == 9: break print(i)
二、作业
1、第一题
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 """ 4 题目： 5 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。 6 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值} 7 """ 8 #python2.7 9 a = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90] 10 b = {"k1": [], "k2": []} 11 for i in a: 12 if i > 66: 13 b["k1"] += [i] 14 else: 15 b["k2"] += [i] 16 print (b)
2、第二题
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 """ 4 查找列表中元素，移除每个元素的空格，并查找以 a或A开头 并且以 c 结尾的所有元素。 5 li = ["alec", " aric", "Alex", "Tony", "rain"] 6 tu = ("alec", " aric", "Alex", "Tony", "rain") 7 dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"} 8 """ 9 #python2.7 10 li = ["alec", " aric", "Alex", "Tony", "rain"] 11 tu = ("alec", " aric", "Alex", "Tony", "rain") 12 dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"} 13 14 a = li + list(tu) + dic.keys() + dic.values()#将元组和字典转换成列表放入列表li中并复制给a 15 b = []#用于存放符合条件的元素 16 for i in a:#循环列表a 17 c = i.strip()#去掉开头或结尾的空格 18 d = c.capitalize()#元素首字母大写 19 if d.startswith("A"):#元素以大写字母A开始 20 if d.endswith("c"):#元素以小写字母c结尾 21 b += [d]#将符合条件的元素放入b中 22 print(b)#打印b
3、第三题
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 """ 4 输出商品列表，用户输入序号，显示用户选中的商品 5 商品 li = ["手机", "电脑", '鼠标垫', '游艇'] 6 """ 7 #python3.x 8 li = ["手机", "电脑", '鼠标垫', '游艇']#商品 9 for k,v in enumerate(li,1):#给li增加序号 10 print(k,v)#打印 11 while True: 12 a =input("请输入序列号：")#用户输入序号 13 print(li[int(a) - 1])#显示用户选中商品
4、第四题
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 """ 4 功能要求： 5 要求用户输入总资产，例如：2000 6 显示商品列表，让用户根据序号选择商品，加入购物车 7 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。 8 附加：可充值、某商品移除购物车 9 """ 10 #python3.4版本 11 12 goods={"a":["电脑",1999,2],"b":["鼠标",10,3],"c":["游艇",20,2],"d":["美女",998,2]}#商场物品清单 13 g=2000#顾客一开始有2000元钱 14 e="您已经将" 15 f="加入购物车，数量为：" 16 z="总金额" 17 yuer="账户余额" 18 gwc=[]#购物车 19 y=0#购物车物品总价值 20 while True:#while循环 21 print(" a:电脑 1999元 b:鼠标 10元 c:游艇 20元 d:美女 998元")#给顾客提示出商品类型和价格 22 while True:#while循环 23 buy=input("请选择您需要买的商品：")#顾客挑选商品 24 if buy in goods.keys():#判断顾客挑选的物品超市是否有 25 buynumbers=input("请输入您要买的数量：")#顾客选购商品的数量 26 buynumber1=int(buynumbers)#因为输入的是字符串，需要转换成数字类型才能判断 27 if buynumber1<=goods[buy][2]:#顾客每次所选货物不能超过上限数量 28 gwc.append([goods[buy][0],goods[buy][1],buynumber1])#将所选商品加入购物车 29 print(e+goods[buy][0]+f+buynumbers)#显示此次加入购物车的商品及数量 30 print(gwc)#显示购物车中商品种类及数量 31 jiesuan=input("取消购物车物品请输入2，继续购物请输入1，结算请输入0：")#用户选择是继续购物还是删除购物车中商品或者去结算 32 jiesuan1=int(jiesuan)#将字符串转换成数字类型 33 if jiesuan1==1:#用户选择继续购物 34 continue#继续 35 elif jiesuan1==2:#用户选择删除购物车中商品 36 while True:#while循环 37 print(" a:电脑 1999元 b:鼠标 10元 c:游艇 20元 d:美女 998元")#给顾客提示出商品类型和价格 38 yichu=input("请选择您需要移除购物车的商品：")#用户选择需要删除的商品 39 if yichu in goods.keys():#商场是有这种商品 40 gwcsl=0#计算购物车中该商品的数量，先赋值为0 41 print (gwc)#显示购物车中详情 42 for k in range(len(gwc)):#将加入购物车次数做个循环 43 if gwc[k][0]==goods[yichu][0]:#判断顾客需要移除的商品是否存在购物车中 44 gwcsl+=gwc[k][2]#顾客要移除商品在购物车中的总数量 45 else:#如过购物车中没有顾客需要移除的商品 46 pass#什么都不做 47 yichushuliang=input("请输入移除数量")#需要移除商品的数量 48 yichushuliang1=int(yichushuliang)#将字符串转换成数字类型 49 if yichushuliang1>gwcsl:#如顾客移除商品数量比购物车中数量多 50 print("购物车没有那么多商品，请重新输入")#打印 51 else:#否则 52 gwc.append([goods[yichu][0],goods[yichu][1],-yichushuliang1])#移除商品 53 print("移除成功")#移除成功 54 break#跳出此次循环 55 else:#商场没有这种商品 56 print("移除购物的物品太多，超过了您放入购物车的数量或商品不存在，请重新输入") 57 else:#用户选择结算 58 for i in gwc:#循环购物车列表 59 x=i[1]*i[2]#计算购物车列表中每个类别的价格 60 y+=x#购物车商品总价格 61 print(z+str(y))#将总价格打印出来 62 if y<=g:#如果顾客的钱比购物车中的总价值高 63 g-=y#购买，花钱 64 print("购买成功")#打印购买成功 65 break#跳出本次购物 66 else:#如果顾客的钱比购物车中的总价值少 67 while True:#充值循环 68 chongzhi=input("余额不足，请选择是否充值 y/n")#用户是否充值 69 if chongzhi=="y":#如果用户充值 70 chongzhi1=input("请输入充值金额:")#充值金额 71 chongzhi2=int(chongzhi1)#将字符串转换成数字 72 g+=chongzhi2#充值成功，总金额 73 if g>=y:#如果现在能购买商品 74 g-=y#购物车结算 75 print("购买成功")#购买成功 76 print(yuer+str(g))#剩余多少钱 77 break#购物结束 78 else:#否则 79 pass#什么都不做，继续循环 80 elif chongzhi=="n":#如果选择不充值 81 break#购物结束 82 else:#该超市不能一次购买那么多 83 print("该超市不能一次购买那么多，请重新选购")#打印 84 else:#客户选择商品有误 85 print("您选择的商品有误，请重新选择")#打印
5、第五题
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 """ 4 用户交互，显示省市县三级联动的选择 5 """ 6 7 8 dic = { 9 "河北": {"石家庄": ["鹿泉", "藁城", "元氏"], "邯郸": ["永年", "涉县", "磁县"]}, 10 "河南":{"郑州市":["新华区","卫东区","石龙区"],"焦作":["马村区","中站区","鹤山区"]} 11 } 12 while True:#循环 13 print(dic.keys())#显示省 14 sheng=input("请输选择省份：")#用户输入省份 15 if sheng in dic.keys():#判断省份是否存在 16 print(dic[sheng].keys())#显示市 17 shi=input("请选择市：")#用户输入市 18 if shi in dic[sheng].keys():#判断市是否存在 19 print(dic[sheng][shi])#显示县 20 xian=input("请选择县:")#用户输入县 21 if xian in dic[sheng][shi]:#判断县是否存在 22 print("选择成功")#选择成功 23 break#跳出循环，结束 24 else:#用户输入的县不存在 25 print("您选择的县不存在，请重新输入")#给用户提示县不存在 26 else:#用户输入的市不存在 27 print("您选择的市不存在，请重新选择")#给用户提示市不存在 28 else:#用户输入的省不存在 29 print("您选择的省份不存在，请重新选择")#给用户提示省不存在
补充
1、python表达式操作符及程序
(1)yield 生成器函数发送协议
(2)is 对象实体测试
(3)X^Y集合对称差
(4)~按位取反
2、变量
（1）变量在第一次赋值市创建
（2）变量在表达式中使用将会被替换成其他的值
（3）变量在表达式中使用前必须先赋值
（4）变量像对象一样不需要在一开始进行声明
3、比较顺序
1==2<3 #1==2and2<3
4、2.x用3.x的计算方法
from __future__ import divison
5/-2 =-3
不管符号截断：math.trunc(5/float(-2))
3.x中9/3 =3.0
5、复数在虚部增加了j或J的后缀
1j*1J=-1+0J
6、进制转换
（1）通过定义int第二个参数来确定转换后的数字的进制（转化的是字符串）
int("64"),hex("100",8)，int("40",16),int("1000000",2)
(2)十进制转化成其他进制的
oct(64),hex(64),bin(b4)
7、str与repr
(1)repr默认的交互模式回显，产生的结果看起来好像他们的代码，
(2)2str用户友好格式
8、1 == 2 < 3 返回Falee and的关系
9、python除法
（1）在Python3.0中，/执行真除非，不管操作数的类型，都返回包含任何余数的一个浮点数
（2）python2中传统除法，如果操作都是整数的话，执行截断整数除法，否则执行浮点除法
（3）//（floor除法）数据类型总是依赖操作的数据类型，真正结果下的最近的整数，其直接效果是向下舍入
（4）调用3.0中的/,from __future__ import division
（5）math.floor=// math.trunc=截取整数，舍去小数
（6） eval()把字符串转换成代码，eval（"0x40"）64
10、位操作
（1）移动位置>>
1 x=1
2 print(bin(x))
3 b=x<<2
4 print(b)
5 print(bin(b))
6 """
7 0b1
8 4
9 0b100
10 """
(2)|取并集
x=1
print(bin(x))
b=3
print(bin(b))
c=x|b
print(c)
print(bin(c))
"""
0b1
0b11
3
0b11
"""
（3）&取交集 ^相当于二级制相加，不进位
11、内置函数
（1）math.sqrt 求根号 pow(2,4)求平方 random.randint(1,10) abs()取整 sum()求和 min()最大值 max（）最小值 round(2.567,2)四舍五入，保留几位小数
（2）random.random() random.randint() random.choice()
12、设置全局精度
1、decimal模块中的其他工具可以用来设置所有小数数值得精度，设置处理错误等 decimal.getcontext().prec=2 decimal.getcontext(str(199+1.33)) decimal.Decimal(1)/decimal.Decimal(7)
2、Fraction()分数Fraction（1,3） Fraction(".25")
13、浮点数转换成分数 （数字）.as_integer_ratio() 数字在最初浮点精度下可能造成不可避免的精度损失，a.limit_denminator(20)
浙公网安备 33010602011771号