python基础知识4--数据类型与变量

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"""intpython2.7

class int(object):
"""
int(x=0) -> integer
int(x, base=10) -> integer Convert a number or string to an integer, or return 0 if no arguments
are given. If x is a number, return x.__int__(). For floating point
numbers, this truncates towards zero. If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance 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): # real signature unknown; restored from __doc__
""" 返回表示该数字的时占用的最少位数 """
"""
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 @classmethod # known case
def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
"""
int.from_bytes(bytes, byteorder, *, signed=False) -> int Return the integer represented by the given array of bytes. The bytes argument must be a bytes-like object (e.g. bytes or bytearray). The byteorder argument determines the byte order used to represent the
integer. If byteorder is 'big', the most significant byte is at the
beginning of the byte array. If byteorder is 'little', the most
significant byte is at the end of the byte array. To request the native
byte order of the host system, use `sys.byteorder' as the byte order value. The signed keyword-only argument indicates whether two's complement is
used to represent the integer.
"""
pass def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
"""
int.to_bytes(length, byteorder, *, signed=False) -> bytes Return an array of bytes representing an integer. The integer is represented using length bytes. An OverflowError is
raised if the integer is not representable with the given number of
bytes. The byteorder argument determines the byte order used to represent the
integer. If byteorder is 'big', the most significant byte is at the
beginning of the byte array. If byteorder is 'little', the most
significant byte is at the end of the byte array. To request the native
byte order of the host system, use `sys.byteorder' as the byte order value. The signed keyword-only argument determines whether two's complement is
used to represent the integer. If signed is False and a negative integer
is given, an OverflowError is raised.
"""
pass def __abs__(self, *args, **kwargs): # real signature unknown
""" abs(self) """
pass def __add__(self, *args, **kwargs): # real signature unknown
""" Return self+value. """
pass def __and__(self, *args, **kwargs): # real signature unknown
""" Return self&value. """
pass def __bool__(self, *args, **kwargs): # real signature unknown
""" self != 0 """
pass def __ceil__(self, *args, **kwargs): # real signature unknown
"""
整数返回自己
如果是小数
math.ceil(3.1)返回4
"""
""" Ceiling of an Integral returns itself. """
pass def __divmod__(self, *args, **kwargs): # real signature unknown
""" 相除，得到商和余数组成的元组 """
""" Return divmod(self, value). """
pass def __eq__(self, *args, **kwargs): # real signature unknown
""" Return self==value. """
pass def __float__(self, *args, **kwargs): # real signature unknown
""" float(self) """
pass def __floordiv__(self, *args, **kwargs): # real signature unknown
""" Return self//value. """
pass def __floor__(self, *args, **kwargs): # real signature unknown
""" Flooring an Integral returns itself. """
pass def __format__(self, *args, **kwargs): # real signature unknown
pass def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass def __ge__(self, *args, **kwargs): # real signature unknown
""" Return self>=value. """
pass def __gt__(self, *args, **kwargs): # real signature unknown
""" Return self>value. """
pass def __hash__(self, *args, **kwargs): # real signature unknown
""" Return hash(self). """
pass def __index__(self, *args, **kwargs): # real signature unknown
""" 用于切片，数字无意义 """
""" Return self converted to an integer, if self is suitable for use as an index into a list. """
pass def __init__(self, x, base=10): # known special case of int.__init__
""" 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
"""
int(x=0) -> integer
int(x, base=10) -> integer Convert a number or string to an integer, or return 0 if no arguments
are given. If x is a number, return x.__int__(). For floating point
numbers, this truncates towards zero. If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance 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, *args, **kwargs): # real signature unknown """ int(self) """
pass def __invert__(self, *args, **kwargs): # real signature unknown
""" ~self """
pass def __le__(self, *args, **kwargs): # real signature unknown
""" Return self<=value. """
pass def __lshift__(self, *args, **kwargs): # real signature unknown
""" Return self<<value. """
pass def __lt__(self, *args, **kwargs): # real signature unknown
""" Return self<value. """
pass def __mod__(self, *args, **kwargs): # real signature unknown
""" Return self%value. """
pass def __mul__(self, *args, **kwargs): # real signature unknown
""" Return self*value. """
pass def __neg__(self, *args, **kwargs): # real signature unknown
""" -self """
pass @staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
""" Create and return a new object. See help(type) for accurate signature. """
pass def __ne__(self, *args, **kwargs): # real signature unknown
""" Return self!=value. """
pass def __or__(self, *args, **kwargs): # real signature unknown
""" Return self|value. """
pass def __pos__(self, *args, **kwargs): # real signature unknown
""" +self """
pass def __pow__(self, *args, **kwargs): # real signature unknown
""" Return pow(self, value, mod). """
pass def __radd__(self, *args, **kwargs): # real signature unknown
""" Return value+self. """
pass def __rand__(self, *args, **kwargs): # real signature unknown
""" Return value&self. """
pass def __rdivmod__(self, *args, **kwargs): # real signature unknown
""" Return divmod(value, self). """
pass def __repr__(self, *args, **kwargs): # real signature unknown
""" Return repr(self). """
pass def __rfloordiv__(self, *args, **kwargs): # real signature unknown
""" Return value//self. """
pass def __rlshift__(self, *args, **kwargs): # real signature unknown
""" Return value<<self. """
pass def __rmod__(self, *args, **kwargs): # real signature unknown
""" Return value%self. """
pass def __rmul__(self, *args, **kwargs): # real signature unknown
""" Return value*self. """
pass def __ror__(self, *args, **kwargs): # real signature unknown
""" Return value|self. """
pass def __round__(self, *args, **kwargs): # real signature unknown
"""
Rounding an Integral returns itself.
Rounding with an ndigits argument also returns an integer.
"""
pass def __rpow__(self, *args, **kwargs): # real signature unknown
""" Return pow(value, self, mod). """
pass def __rrshift__(self, *args, **kwargs): # real signature unknown
""" Return value>>self. """
pass def __rshift__(self, *args, **kwargs): # real signature unknown
""" Return self>>value. """
pass def __rsub__(self, *args, **kwargs): # real signature unknown
""" Return value-self. """
pass def __rtruediv__(self, *args, **kwargs): # real signature unknown
""" Return value/self. """
pass def __rxor__(self, *args, **kwargs): # real signature unknown
""" Return value^self. """
pass def __sizeof__(self, *args, **kwargs): # real signature unknown
""" Returns size in memory, in bytes """
pass def __str__(self, *args, **kwargs): # real signature unknown
""" Return str(self). """
pass def __sub__(self, *args, **kwargs): # real signature unknown
""" Return self-value. """
pass def __truediv__(self, *args, **kwargs): # real signature unknown
""" Return self/value. """
pass def __trunc__(self, *args, **kwargs): # real signature unknown
""" Truncating an Integral returns itself. """
pass def __xor__(self, *args, **kwargs): # real signature unknown
""" Return self^value. """
pass denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""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"""python3.5

python2.7
>>> a=9223372036854775807
>>> a
>>> a+=1
>>> a
9223372036854775808Lpython3.5
>>> a=9223372036854775807
>>> a
>>> a+=1
>>> a查看

方法：
1.capitalize() 首字母大写
2.casefold() 大写字母转小写（更牛逼，不仅仅适用于英文字母的大小写转换，也适用于欧洲其他国家字母大小写转换）
** 3.lower() 字母大写转小写（普通英文字母转换）
islower() 判断变量的值是否全部是小写
** 4.upper() 小写改大写
isupper() 判断是否是大写
5.count(“n”,3,6) 在第3至第6个字符中，计算字符n在变量中出现的次数，3，6可以省略，只保留 count("n")
6.encode 后期讲
7.decode 后期讲
8.endswith('a') 判断变量是否以a字母结尾，如果正确返回 True ，错误返回 False
9.startswith('a') 判断变量是否以a字母开头，如果正确返回 True ，错误返回 False
*** 10.find('a',5,8) 变量中查找字符‘a’在变量中第一个出现的位置,（注意：第一个字符从0开始数）从第5个字符开始到第8个字符结束，如果结果是-1，表示没有找到
index() 判断字符所在字符串中的位置 a = 'abc'
v = a.index('b')
print(v) 11.format(name='zhangsan',age=30) 格式化，将字符串中占位符替换为指定的值，举例：
a = 'I am {name},age is {age}'
v = a.format(name = 'zhangsan', age = 30)
print(v) 如果占位符位置按顺序用0，1，2...替代，则format中直接按顺序用值替换即可
b = 'I am {0},age is {1}'
v = a.format('zhangsan',30)
print(v) 12.isalnum() 判断变量是否只包含字母和数字，如是返回True，否，返回False
13.expandtabs(6) 表示变量以6个一组，如果该组内没有tab，则略过，如有tab，则该组tab前面的字符+tab为6个字符，去掉tab前面的字符个数，表示tab所占用的空格数量
a = 'zhangsan\thi'
v = a.expandtabs(6)
print(v,len(v))
----------------
zhangsan hi 14 制作表格，循环提示用户输入用户名、密码，邮箱（不能超过20个字符），如果用户输入q或Q，表示不再继续输入，打印用户输入的结果：
s = ''
while True:
v1 = input("请输入用户名:")
if v1.lower() == 'q':
break
v2 = input("请输入密码:")
v3 = input("请输入邮箱:")
template = "{0}\t{1}\t{2}\n"
v = template.format(v1,v2,v3)
s += v
print(s.expandtabs(20)) 常用于格式化输出：
test = "username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123"
v = test.expandtabs(20)
print(v)
-------------------------
username email password
laiying ying@q.com 123
laiying ying@q.com 123
laiying ying@q.com 123 14.isalpha() 变量中是否只包含字母，汉字也算，如是返回True，否，返回False
15.isdecimal() 判断变量的值是否是数字，仅可识别标准数字
16.isdigit() 判断变量的值是否是数字，可以识别一些特殊的数字，比如②
17.isidentifier() 判断变量是否符合变量名标准 判断用户输入的字母和数字中，有多少个字母和数字
c1 = 0
c2 = 0
val = input(">>>")
for item in val:
# item是数字
if item.isdecimal():
c1 += 1 # 如果item是字母
if item.isalpha():
c2 += 1
print("总数字是:" + str(c1))
print("总字母是:" + str(c2))*** 18.strip 删除变量左右两侧的空格，移除换行\n,\t，另外还可以去除指定的字符x strip('xyz')，而且，xyz出现在变量中，可以不分顺序，只要包含即可删除，下面同
lstrip 删除变量左侧的空格，移除换行\n,\t
rstrip 删除变量右侧的空格，移除换行\n,\t
19.isdecimal() 识别数字（仅是阿拉伯数字）
20.isdigit() 识别数字（含数字符号，如②）
21.isnumeric() 识别数字（所有数字，如二，②，Ⅱ，贰）
22.isprintable() 是否包含不可见的字符（包含：\n，\t，结果为False）
23.isspace() 判断变量是否全是空格
24.istitle() 判断标题首字母是否是大写，如一句话含多个单词，每个单词首字母要均为大写
** 25.title() 标题首字母全部更改为大写
****26.join(text) 字符串每个字符按照指定分隔符拼接 text = '你是风儿我是沙'
print(text)
v = '_'.join(text)
print(v) 27.center(20,"*") 20个字符宽度，变量名居中，左右两侧以*填充，仅限一个字符，默认空格填充，可以省略
28.ljust(20,*) 20个字符宽度，变量名居左，右侧以*填充，仅限一个字符，默认空格填充，可以省略
29.rjust(20,*) 20个字符宽度，变量名居右，左侧以*填充，仅限一个字符，默认空格填充，可以省略
30.zfill(20) 在变量的左侧用0填充，不可以用其他字符
31.maketrans() 字符串替换
translate()
a = 'abcd'
b = ''
text = 'nihaoma?nizaiganma?'
temp = str.maketrans(a,b)
new_text = text.translate(temp)
print(new_text)
32.partition('x') 默认从左侧找到第一个x进行3份切割，x自身元素可以拿到
rpartition('x') 从右侧找到第一个x进行3份切割，x自身元素可以拿到
*** split('x',2) 字符串切割，本身字符拿不到，2为切分几次，x自身元素不可以拿到
rsplit('x',2) 从右侧字符串切割，本身字符拿不到，2为切分几次，x自身元素不可以拿到
splitlines() 分割换行，值可以是True，False表示是否保留换行 加法计算器：（如 10 + 5）
temp = input("Please input numbers:")
v = temp.split('+')
# print(v)
t1 = int(v[0])
t2 = int(v[1])
f = t1 + t2
print(f) 33.startswith('a') 判断是否以a开头
endswith('a') 判断是否以a结尾
34.swapcase() 大小写转换
35.replace() 替换字符串
用aaa替换变量a中的字符a，替换出现的第一个a，可以省略后面的1，表示全部替换
a = 'zhang'
v = a.replace('a', 'aaa', 1)
print(v) 敏感词替换，用***代替用户输入的苍老师，东京热
v = input(">>>")
v = v.replace('苍老师', '***')
v = v.replace('东京热', '***')
print(v) 必须要记住8个基本方法
-----------------------
join
split
find
strip
upper
lower
title
len
replace

在列表中添加元素：
在列表末尾添加元素：
在列表中添加新元素时，最简单的方式是将元素附加到列表末尾，给列表附加元素时，它将添加到列表末尾
bicycles.append("meituan")
print(bicycles)
方法append()将元素“meituan”添加到列表末尾，而不影响列表中其他所有元素
方法append()让动态地创建列表易如反掌，例如，先创建一个空列表，再使用一系列的append()语句添加元素，下面我们实际操作一下：
bicycles = []
bicycles.append("ofo")
bicycles.append("mobai")
bicycles.append("youjiu")
bicycles.append("didi")
print(bicycles) 在列表中插入元素：
使用方法insert()可在列表中任何位置添加新元素，为此，你需要将指定新元素的索引和值
bicycles.insert(0,"fenghuang")
print(bicycles) 在这个示例中，将值“fenghuang”插入到列表开头，方法insert在索引0处添加空间，并将值“fenghuang”存储到这个地方，这种操作将列表中既有的每个元素都右移一个位置
['fenghuang', 'ofo', 'mobai', 'youjiu', 'didi'] 清空列表：
方法：clear() 清空列表所有值
a.clear() 浅拷贝：
仅拷贝列表第一层级
方法：copy()
v = a.copy() 深拷贝：
改变列表里第二层级对象，深拷贝后的列表更改不影响原始列表
import copy
b = [[1, 2], 'a', 'b', 'c', 1, 2, 3]
c=copy.deepcopy(b)
c[0][1]=222
print(b)
print(c) 计算元素出现的个数：
方法：count()
a = ['zhsng', 'li', 'wang']
v = a.count('li')
print(v) 扩展原列表（追加可迭代（for循环）对象）：
目前可循环对象：字符串，列表，元组，字典（数字不可以循环）
a = ['zhsng', 'li', 'wang']
a.extend([123, 'abc'])
print(a)
-----------------------------
['zhsng', 'li', 'wang', 123, 'abc'] 查询列表元素索引位置：
index() (从前往后找，找到第一个就不再继续往下找，如果需要，可以指定起始位置进行精确查找) a = ['zhsng', 'li', 'wang']
v = a.index('li')
print(v) a = ['zhsng', 'li', 'wang', 'li']
v = a.index('li', 2, 4)
print(v) 从列表中删除元素：
经常需要从列表中删除一个或多个元素，例如：玩家将空中的一个外星人射杀后，你很可能要将其从存活的外星人列表中删除，当用户在你创建的web应用中注销其账户时，你需要将该用户从活跃
用户列表中删除，你可以根据位置或值来删除列表中的元素 使用del语句删除元素：
如果知道要删除的元素在列表中的位置，可以使用del语句
del bicycles[1]
print(bicycles)
['fenghuang', 'mobai', 'youjiu', 'didi'] 此例删除了列表中第二个元素
使用del可以删除任何位置的列表元素，条件是知道其索引
使用del语句删除列表元素，以后就无法再访问它了 使用方法pop()删除元素：
有时候，你要将元素删除后，并接着使用它的值。例如：你可能需要获取刚被射杀的外星人的x和y坐标，比便在相应的位置显示爆炸效果，在web应用程序中，你可能将用户从活跃成员列表中删除，将其添加到非活跃成员中
方法pop()可删除列表末尾的元素，并让你能够接着使用它，pop源自这样的类比，列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素
bicycles = []
bicycles.append("ofo")
bicycles.append("mobai")
bicycles.append("youjiu")
bicycles.append("didi")
print(bicycles)
poped_bicycle = bicycles.pop()
print(bicycles)
print(poped_bicycle)
------------------------------------------------
['ofo', 'mobai', 'youjiu', 'didi']
['ofo', 'mobai', 'youjiu']
didi 弹出列表中任何位置的元素
实际上，你可以使用pop()来删除列表中任何位置的元素，只需在括号中指定要删除的元素索引即可
别忘了，每当你使用pop()时，被弹出的元素就不在列表中了 如果你不确定该使用del语句还是pop()方法时，下面是一个简单的判断标准：
如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句，如果你要在删除元素后还能继续使用它，就使用方法pop() 根据值删除元素：
有时候，你不知道要从列表中删除的值所处的位置，如果你只知道要删除的元素的值，你可以使用方法remove()
使用remove()从列表中删除元素时，也可以使用它的值，
例如：我们要从列表bicycles中删除值“yongjiu”
bicycles = ['meituan', 'fenghuang', 'yongjiu', 'didi']
print(bicycles)
too_expensive = "yongjiu"
bicycles.remove(too_expensive)
print(bicycles)
print("\nA " + too_expensive.title() + "is too expensive for me!" "")
-----------------------------------
['meituan', 'fenghuang', 'yongjiu', 'didi']
['meituan', 'fenghuang', 'didi'] A Yongjiuis too expensive for me! 注意：方法remove()只删除第一个指定的值，如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值组织列表：创建的列表中，元素的排列顺序常常时无法预测的，因为你并非总能控制用户提供的数据顺序，这虽然在大多数情况下不可避免，但你经常需要以特定的顺序呈现信息
有时候，你希望保留列表元素最初的排列顺序，而有时候又需要调整排列顺序，python提供了很多组织列表的方式，可根据具体情况选用字符，字母（大小写），数字排序按照ASCII特码从小到大排序
字符 < 数字 < 大写字母 < 小写字母sort()
使用方法sort()对列表永久性排序，再也无法恢复到原来的排列顺序了：
bicycles = ['meituan', 'fenghuang', 'yongjiu', 'didi']
print(bicycles)
bicycles.sort()
print(bicycles)
----------------------------
['meituan', 'fenghuang', 'yongjiu', 'didi']
['didi', 'fenghuang', 'meituan', 'yongjiu'] 还可以按与字母顺序相反的顺序排列列表元素，为此，只需要向sort()方法传递参数 reverse=True ，同样，对列表元素排列顺序时永久性的 bicycles = ['meituan', 'Fenghuang', 'Yongjiu', 'didi']
print(bicycles)
bicycles.sort()
print(bicycles)
bicycles.sort(reverse=True)
print(bicycles)
-------------------------------
['meituan', 'Fenghuang', 'Yongjiu', 'didi']
['Fenghuang', 'Yongjiu', 'didi', 'meituan']
['meituan', 'didi', 'Yongjiu', 'Fenghuang']sorted()
要保留列表元素原来的排列顺序，同时以特定的顺序呈现他们，可使用函数 sorted()，它能让你按特定的顺序显示列表元素，同时不影响他们在列表中的原始排列顺序 bicycles = ['meituan', 'Fenghuang', 'Yongjiu', 'didi']
print(bicycles)
print(sorted(bicycles))
print(bicycles)
-----------------------------
['meituan', 'Fenghuang', 'Yongjiu', 'didi']
['Fenghuang', 'Yongjiu', 'didi', 'meituan']
['meituan', 'Fenghuang', 'Yongjiu', 'didi'] 先进行原始排序，再进行特定顺序显示列表，最后再次核实，确认列表的排列顺序与以前相同（print(sorted(bicycles)) 仅当条排序语句生效） 注意：调用函数sorted()后，列表元素的排列顺序并没有变，如果你要按照与字母顺序相反，显示列表，也可以向函数sorted() 传递参数 reverse=True倒着打印列表：
要反转列表元素的排列顺序，可使用方法reverse()
bicycles = ['meituan', 'Fenghuang', 'Yongjiu', 'didi']
print(bicycles)
bicycles.reverse()
print(bicycles)
--------------------------
['meituan', 'Fenghuang', 'Yongjiu', 'didi']
['didi', 'Yongjiu', 'Fenghuang', 'meituan'] 注意：reverse()不是按照与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序
方法reverse()永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse()即可确定列表的长度：
使用函数len()可快速的获悉列表的长度，在你需要完成如下任务时，len()很有用，确定还有多少外星人未被射杀，需要管理多少项可视化数据，网站有多少注册用户等
bicycles = ['meituan', 'Fenghuang', 'Yongjiu', 'didi']
print(bicycles)
print(len(bicycles))
---------------------
['meituan', 'Fenghuang', 'Yongjiu', 'didi']
4 注意：python计算列表元素时从1开始，因此确定列表长度时，你应该不会遇到差一错误使用列表时避免索引错误：
刚开始使用列表时，经常会遇到一种错误，假设你有一个包含4个元素的列表，却要求获取第五个元素
bicycles = ['meituan', 'Fenghuang', 'Yongjiu', 'didi']
print(bicycles[4])
------------------------
Traceback (most recent call last):
File "/root/python/ex1/py1.py", line 10, in <module>
print(bicycles[4])
IndexError: list index out of range 鉴于列表索引差一特征，这种错误很常见，有些人从1开始数，因此以为第4个元素的索引是4，但在python中，第四个元素的索引是3，因为索引是从0开始的
索引错误意味着python无法理解你指定的索引，在程序发生错误时，请尝试将你指定的索引减一，然后再次运行，看看结果是否正确 别忘了，每当需要访问最后一个元素时，都可以使用索引-1，这在任何情况下都行之有效，即便你最后一次访问列表后，其长度发生了变化
bicycles = ['meituan', 'Fenghuang', 'Yongjiu', 'didi']
print(bicycles[-1])
-----------------------------
didi 索引-1总是返回最后一个列表元素，仅当列表为空时，这种访问最后一个元素的方式才会导致错误：
car = []
print(car[-1])
------------------
Traceback (most recent call last):
File "/root/python/ex1/py1.py", line 12, in <module>
print(car[-1])
IndexError: list index out of range注意：发生索引错误却找不到解决办法时，请尝试将列表或其长度打印出来，列表可能与你以为的截然不同，在程序对其进行了动态处理时尤其如何，通过查看列表或其包含的元素，可帮助你找出这种逻辑错误操作列表：遍历整个列表：
经常需要遍历列表的所有元素，对每个元素执行相同的操作，可以使用for循环
举例：使用for循环遍历朋友的姓名
names = ['zhangsan', 'lisi', 'wangwu']
for name in names:
print(name)for循环：
循环是让计算机自动完成重复工作的常见方式之一
for name in names:
这行代码让python获取列表names中的第一个值（‘zhangsan’），并将其存储到变量name中（相当于还是要先给name变量赋值），解下来，python读取下一行代码
print(name)
它让python打印name的值，依然是‘zhangsan’，鉴于该列表还包含其他值，python返回循环的第一行
for name in names:
python获取列表中的下一个名字‘lisi’，并将其存储到变量name中，再执行打印下面的print(name)代码
接下来，python再次执行整个循环，对列表最后一个值‘wangwu’进行处理，至此，列表没有其他值了，因此python接着执行下一行代码，在这个示例中
for循环后面没有其他代码，因此程序就此结束了 刚开始使用循环时请牢记，对列表中的每个元素，都将执行循环指定的步骤，而不管列表包含多少元素，如果列表包含一百万个元素，python就重复执行指定的步骤一百万次，且通常速度非常快
另外，编写for循环时，对于用于存储列表中每个值的临时变量，可指定任何名称，然后，选择描述单个列表元素的有意义名称大有帮助
例如：
for cat in cats：
for dog in dogs：
for item in items：
这些命名约定有助于你明白for循环中将对每个元素执行的操作，使用单数和复数式名称，可帮助你判断代码段处理的是单个列表元素还是整个列表在for循环中执行更多的操作
names = ['zhangsan', 'lisi', 'wangwu']
for name in names:
print(name.title() + ", You are my friend!")
print('Welcome to my home' + ": " + name.title()) 在for循环中，想包含多少行代码都可以，在代码 for name in names 后面，每个缩进的代码行都是循环的一部分，且将对列表中的每个值都执行一次
实际上你会发现使用for循环对每个元素执行众多不同的操作很有用在for循环结束后执行一些操作：
在for循环后面，没有缩进的代码只执行一次，而不会重复执行
使用for循环处理数据是一种对数据集执行整体操作的不错方式避免缩进错误：
python根据缩进来判断代码行与前一个代码行的关系，当你开始编写必须正确缩进代码时，需要注意一些缩进错误： 忘记缩进：对于for语句后面且属于循环组成部分的代码行，一定要缩进 忘记缩进额外的代码行：有时候，循环能够运行而不会报错，但结果可能会出乎意料，这通常是一个逻辑错误，从语法上，这些代码是合法的，但由于存储逻辑错误，结果并不符合预期 不必要的缩进：如果不小心缩进了无需缩进的代码行，python将指出这一点，为了避免意外错误，请只缩进需要缩进的代码 循环后不必要的缩进：如果你不小心缩进了应在循环结束后执行的代码，这些代码将针对每个列表元素重复执行，在有些情况下，这可能导致报告语法错误，但在大多数情况下，这只会导致逻辑错误 遗漏了冒号：for语句结尾的冒号告诉python，下一行是循环的第一行，如果你不小心遗漏了冒号，将导致语法错误创建数字列表；列表非常适合用于储存数字集合，而python提供了很多工具，可以帮助你高效地处理数字列表
使用函数range()
python函数range()让你能够轻松地生成一系列数字
for value in range(1, 5):
print(value)
--------------------
1
2
3
4
在这个示例中，range()只是打印数字1-4，这是你在编程语言中经常看到的差一行为的结果
函数range()让python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二值（这里是5）
要打印数字1-5，需要使用range(1,6)
使用range()时，如果输出不符合预期，请尝试将指定的值加1或减一使用range()创建数字列表：
要创建数字列表，可以使用函数list()将range()的结果直接转换为列表，如果将range()作为list()的参数，输出将是一个数字列表
numbers = list(range(1, 6))
print(type(numbers), numbers)
-----------------------------------
<class 'list'> [1, 2, 3, 4, 5] 使用函数range()时，还可以指定步长，例如打印1-10内的偶数
numbers = list(range(2, 11, 2))
print(type(numbers), numbers)
------------------------------
<class 'list'> [2, 4, 6, 8, 10] 使用函数range()几乎能够创建任何需要的数字集，例如，创建一个1-10数字平方的列表
numbers = []
for number in range(1, 11):
seq = number ** 2
numbers.append(seq)
print(numbers)
-------------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 为了让这些代码更简洁，可以不使用临时变量，而直接将每个计算得到的值附加到列表末尾
numbers = []
for number in range(1, 11):
numbers.append(number ** 2)
print(numbers)
------------------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
创建更复杂的列表时，可使用上述两种方法中的任何一种，有时候，使用临时变量会让代码更易读，而在其他情况下，这样做只会让代码无谓地变长，
你首先应该考虑的是，编写清晰易懂且能完成所需功能的代码，等到审核代码时，再考虑采用更高效的方法对数字列表进行简单的统计计算
有几个专门用于处理数字列表的函数：
min()
max()
sum() numbers = []
for number in range(1, 11):
numbers.append(number ** 2)
print(numbers)
print(min(numbers))
print(max(numbers))
print(sum(numbers))
----------------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
1
100
385 1-100求和
numbers = []
for number in range(1,101):
numbers.append(number)
print(sum(numbers))
---------------------------
5050列表解析：
前面介绍生成列表的方式包含了三四行代码，而列表解析让你只需编写一行代码就能生成这样的列表，列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素，这里for循环语句末尾没有冒号：
numbers = [temp ** 2 for temp in range(1, 11)]
print(numbers)
---------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 要创建自己的列表解析，需要经过一定的练习，但能够熟练地创建常规列表后，你会发现这样做是完全值得的，当你觉得编写三四行代码来生成列表有点繁琐时，就应该考虑列表解析了使用列表的一部分：切片 要创建切片，可指定要使用的第一个元素的索引和最后一个元素的索引加1，与函数range()一样，python在到达你指定的第二个索引前面的元素后停止，要输出列表中的前三个元素，需要指定索引0-3，这将输出分别为0，1，2的元素
numbers = [temp - 1 for temp in range(1, 11)]
print(numbers[0:3])
---------------------
[0, 1, 2] 如果你没有指定第一个索引，python将自动从列表开头开始：
numbers = [temp - 1 for temp in range(1, 11)]
print(numbers[:5])
---------------------
[0, 1, 2, 3, 4] 要将切片终止于列表末尾，也可以使用类似的语法：
numbers = [temp - 1 for temp in range(1, 11)]
print(numbers[8:])
--------------------
[8, 9] 无论列表有多长，这种语法都能够让你输出从特定位置到列表末尾的所有元素，前面说过，负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片
numbers = [temp - 1 for temp in range(1, 11)]
print(numbers[-3:])
-------------------------
[7, 8, 9] 遍历切片
如果要遍历列表的部分元素，可以在for循环中使用切片，下面的例子，我们遍历了前三名队员，并打印了他们的名字，这里我们并没有遍历整个队员的列表，而只是遍历前三名
names = ['zhangsan', 'lisi', 'wangwu', 'zhouliu']
for name in names[:3]:
print(name)
-------------------------------
zhangsan
lisi
wangwu 在很多情况下，切片都很有用，例如：在编写游戏时，你可以在玩家退出游戏时将其最终得分加入到一个列表中，然后，为获取该玩家的三个最高得分，你可以将该列表按降序排列，再创建一个只包含前三个得分
的切片。在处理数据时，可使用切片来进行批量处理，编写web应用程序时，可使用切片来分页显示信息，并在每页显示数量合适的信息 复制列表
你经常需要根据既有列表创建全新的列表，要复制列表，可创建一个包含完整列表的切片，方法是同时省略起始索引和终止索引([:])，这让python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表
my_goods = ['pizza', 'cake', 'fala']
friend_goods = my_goods[:]
print(my_goods)
print(friend_goods)
-------------------------
['pizza', 'cake', 'fala']
['pizza', 'cake', 'fala'] 验证：向每个列表各添加了一种食品
my_goods = ['pizza', 'cake', 'fala']
friend_goods = my_goods[:]
my_goods.append('coffer')
friend_goods.append('ice')
print(my_goods)
print(friend_goods)
----------------------
['pizza', 'cake', 'fala', 'coffer']
['pizza', 'cake', 'fala', 'ice'] 这里不能使用赋值的方法将 my_goods赋值给 friend_goods，因为这两个列表都指向了同一个列表，并不是完全独立的两个列表 注意：现在暂时不要考虑这个示例中的细节，基本上，当你试图使用列表的副本时，如果结果出乎意料，请确认你像第一个示例那样使用切片复制了列表

字典方法