Python 基础  一

一、关于Python的介绍

python的创始人为吉多·范罗苏姆（Guido van Rossum），这一两年在国内很流行，应用很广泛。

二、Python的基础知识（1）

1.编译和解释的区别　

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;

解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的.（Python就是解释型的语言）

这是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式)

2.Python的安装

  1. 1、下载安装包
  2.     https://www.python.org/downloads/
  3. 2、安装
  4.     默认安装路径：C:\python27
  5. 3、配置环境变量
  6.     【右键计算机】--》【属性】--》【高级系统设置】--》【高级】--》【环境变量】--》【在第二个内容框中找到 变量名为Path 的一行，双击】 --> 【Python安装目录追加到变值值中，用 ； 分割】
  7.     如：原来的值;C:\python27，切记前面有分号

三、变量

3.1、变量声明：

1. Python将所有数据存为内存对象
2. Python中，变量事实上是指向内存对象的引用
3. 动态类型：在任何时刻，只要需要，某个对象引用都可以重新引用一个不同的对象（可以是不同的数据类型）内建函数type()用于返回给定数据项的数据类型
4. "="用于将变量名与内存中的某个对象绑定：如果对象实现存在，就直接进行绑定；否则，则由"="创建引用的对象,变量名也是对象存在内存，比如：name='jerry',name这个指针指向jerry，name='tom'的时候，name是指针指向tom，但是jerry仍在内存中存放着，只是没有被变量名指向，到一定时候会被垃圾收集器回收，和java有点像。其中当test='jerry'时，test和name这两个变量名指向内存的地址是一样的。id(test),id(name)，变量名是内存引用的标识或符号。

3.2、变量定义的规则：
1. 变量名只能是 字母、数字或下划线的任意组合
2. 变量名的第一个字符不能是数字
3. 以下关键字不能声明为变量名
　　 ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise','return', 'try', 'while', 'with', 'yield']

3.3、变量的官方建议命名实例

  1. 使用下划线'_'作为连接,如 name_variables

四、字符编码

ASCII 其最多只能用 8 位来表示（一个字节），即：2**8 = 256-1，所以，ASCII码最多只能表示 255 个符号，python2.x解释器默认是ASCII编码。

Unicode规定所有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536，注：此处说的的是最少2个字节，可能更多，比如汉字就需要3个字节，python3.x解释器默认是Unicode编码。

UTF-8，是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ASCII码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存

五、输入、输出、注释
1、Python3.x提供了一个input()，可以让用户输入字符串。比如输入用户的名字：
    python3中格式化输出默认接收的都视为字符串,如果你获取的是要数字类型则需要另外强制转换为int()转换为数字类型才能获得数字

输入密码时，如果想要不可见，需要利用 getpass 模块中的 getpass 方法

input()在输入字符串的时候报错,变量未定义,数值型则没有报错,如果是字符串则需要引号'' or ""，或者事先定义变量赋值

注释：

#号可以从一行的任何地方开始
'''''',"""""",三引号用于多行注释
\,表示续行符
注意：如果''''''三引号是在一个def 函数或者class 定义类的下方则是对这个函数或者类的说明,可以通过__doc__动态获得文档子串

六、流程控制

1.If语句与流程控制

python的比较操作：

所有的Python对象都支持比较操作：

    • 可用于测试值相等、相对大小等
    • 如果是复合对象，python会检查其所有部分，包括自动遍历各级嵌套对象，知道可以得出最终结果

测试操作符：

    • "==" 操作符测试值的相等性
    • "is" 表达式测试对象的一致性
    • "in" 成员关系测试

如何实现比较操作：

python中不同类型的比较方法：

    • (1)数字：通过相对大小进行比较
    • (2)字符串：按照字典次序逐次进行比较
    • (3)列表和元组：自左至右比较各部分内容
    • (4)字典：对排序之后的(键、值)列表进行比较

python中真和假的含义：

    • (1)非0数字为真，否则为假
    • (2)非空对象为真，否则为假
    • (3)None则始终为假

比较和相等测试会递归地应用于数据结构中
返回值为True或False

组合条件测试：

    • X and Y: 与运算
    • X or Y: 或运算
    • not X : 非运算

if测试的语法结构：

if boolean_expression1:

suite1

elif boolean_expression2:

suite2

else:

else_suite

注意： 
elif语句是可选的
仅用与占位，而后在填充相关语句时，可以使用pass

if/else三元表达式：

通常在为某变量设定默认值时通常用到如下表达式

A = X if Y else Z

或：

if Y:

A = X

else

A = Z

其通用条件表达式语法格式为：

expression1 if boolean_express else expression2

如果boolean_express的值为True，则条件表达式的结果为express1,否则为express2

七、循环for,while

循环机制及应用场景
while循环：

    • (1)用于编写通用迭代结构
    • (2)顶端测试为真即会执行循环体，并会重复多次测试直到为假后执行循环后的其他语句

for循环：

    • (1)一个通用的序列迭代器，用于遍历任何有序的序列对象内的元素
    • (2)可用于字符串、元组、列表和其他的内置可迭代对象，以及通过类所创建的新对象

python也提供了一些能够进行隐性迭代的工具：

    • (1)in成员关系测试
    • (2)列表解析
    • (3)map、reduce和filter函数

break: 跳出最内层的循环
continue: 跳出所处的最近层循环的开始处
pass: 占位语句

外层变量，可以被内层代码使用

内层变量，不应被外层代码使用

while循环：

while True: 死循环

语法格式：

while boolean_express:

while_suite

else:

else_suite

注意：

      1. else分支为可选部分
      2. 只要boolean_express的结果为True，循环就会执行
      3. boolean_express的结果为False时终止循环，此时如果有else分支，则会执行

for循环：

语法格式：

for expression1 in iterable:

for_suite

else:

else_suite

通常，expression或是一个单独的变量，或是一个变量序列，一般以元组的形式给出
如果以元组或列表用于expression,则其中的每个数据项都会拆分到表达式的项

T =
[(1,2),(3,4),(5,6),(7,8)]

for (a,b) in T:

　　print(a,b)

编写循环的技巧：
(1)for循环比while循环执行速度快
(2)python提供了两个内置函数，用于在for循环中定制特殊的循环python3.x 只有range,python2.x有(range,xrange)

      • range: 一次性地返回连续的整数列表
      • xrange: 一次产生一个数据元素，相较于range更节约空间
      • zip：返回并行的元素元组的列表，常用于在for循环中遍历数个序列

八、数据类型

核心数据类型：

  • 数字：int, long(python3.5已经没有), float, complex, bool
  • 字符：str, unicode
  • 列表：list
  • 字典：dict
  • 元组：tuple
  • 集合：set(可变集合),frozenset(不可变集合)
  • 文件：file

数字类型：

python的数字字面量：整数，布尔型，浮点数，复数，所有数字类型均为不可变

int（整型）

数字类型：

python的数字字面量：整数，布尔型，浮点数，复数，所有数字类型均为不可变

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

bool(布尔型)

　   真或假
　　1 或 0

float(浮点型)

数字操作：+ , -, *, /, //, **, %, -x, +x

附上源码：

  1. class int(object):
  2.     """
  3.     int(x=0) -> int or long
  4.     int(x, base=10) -> int or long
  5.  
  6.     Convert a number or string to an integer, or return 0 if no arguments
  7.     are given.  If x is floating point, the conversion truncates towards zero.
  8.     If x is outside the integer range, the function returns a long instead.
  9.  
  10.     If x is not a number or if base is given, then x must be a string or
  11.     Unicode object representing an integer literal in the given base.  The
  12.     literal can be preceded by '+' or '-' and be surrounded by whitespace.
  13.     The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  14.     interpret the base from the string as an integer literal.
  15.     >>> int('0b100', base=0)
  16.     """
  17.     def bit_length(self):
  18.         """ 返回表示该数字的时占用的最少位数 """
  19.         """
  20.         int.bit_length() -> int
  21.  
  22.         Number of bits necessary to represent self in binary.
  23.         >>> bin(37)
  24.         '0b100101'
  25.         >>> (37).bit_length()
  26.         """
  27.         return 0
  28.  
  29.     def conjugate(self, *args, **kwargs): # real signature unknown
  30.         """ 返回该复数的共轭复数 """
  31.         """ Returns self, the complex conjugate of any int. """
  32.         pass
  33.  
  34.     def __abs__(self):
  35.         """ 返回绝对值 """
  36.         """ x.__abs__() <==> abs(x) """
  37.         pass
  38.  
  39.     def __add__(self, y):
  40.         """ x.__add__(y) <==> x+y """
  41.         pass
  42.  
  43.     def __and__(self, y):
  44.         """ x.__and__(y) <==> x&y """
  45.         pass
  46.  
  47.     def __cmp__(self, y):
  48.         """ 比较两个数大小 """
  49.         """ x.__cmp__(y) <==> cmp(x,y) """
  50.         pass
  51.  
  52.     def __coerce__(self, y):
  53.         """ 强制生成一个元组 """
  54.         """ x.__coerce__(y) <==> coerce(x, y) """
  55.         pass
  56.  
  57.     def __divmod__(self, y):
  58.         """ 相除，得到商和余数组成的元组 """
  59.         """ x.__divmod__(y) <==> divmod(x, y) """
  60.         pass
  61.  
  62.     def __div__(self, y):
  63.         """ x.__div__(y) <==> x/y """
  64.         pass
  65.  
  66.     def __float__(self):
  67.         """ 转换为浮点类型 """
  68.         """ x.__float__() <==> float(x) """
  69.         pass
  70.  
  71.     def __floordiv__(self, y):
  72.         """ x.__floordiv__(y) <==> x//y """
  73.         pass
  74.  
  75.     def __format__(self, *args, **kwargs): # real signature unknown
  76.         pass
  77.  
  78.     def __getattribute__(self, name):
  79.         """ x.__getattribute__('name') <==> x.name """
  80.         pass
  81.  
  82.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  83.         """ 内部调用 __new__方法或创建对象时传入参数使用 """
  84.         pass
  85.  
  86.     def __hash__(self):
  87.         """如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""
  88.         """ x.__hash__() <==> hash(x) """
  89.         pass
  90.  
  91.     def __hex__(self):
  92.         """ 返回当前数的 十六进制 表示 """
  93.         """ x.__hex__() <==> hex(x) """
  94.         pass
  95.  
  96.     def __index__(self):
  97.         """ 用于切片，数字无意义 """
  98.         """ x[y:z] <==> x[y.__index__():z.__index__()] """
  99.         pass
  100.  
  101.     def __init__(self, x, base=10): # known special case of int.__init__
  102.         """ 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
  103.         """
  104.         int(x=0) -> int or long
  105.         int(x, base=10) -> int or long
  106.  
  107.         Convert a number or string to an integer, or return 0 if no arguments
  108.         are given.  If x is floating point, the conversion truncates towards zero.
  109.         If x is outside the integer range, the function returns a long instead.
  110.  
  111.         If x is not a number or if base is given, then x must be a string or
  112.         Unicode object representing an integer literal in the given base.  The
  113.         literal can be preceded by '+' or '-' and be surrounded by whitespace.
  114.         The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  115.         interpret the base from the string as an integer literal.
  116.         >>> int('0b100', base=0)
  117.         # (copied from class doc)
  118.         """
  119.         pass
  120.  
  121.     def __int__(self):
  122.         """ 转换为整数 """
  123.         """ x.__int__() <==> int(x) """
  124.         pass
  125.  
  126.     def __invert__(self):
  127.         """ x.__invert__() <==> ~x """
  128.         pass
  129.  
  130.     def __long__(self):
  131.         """ 转换为长整数 """
  132.         """ x.__long__() <==> long(x) """
  133.         pass
  134.  
  135.     def __lshift__(self, y):
  136.         """ x.__lshift__(y) <==> x<<y """
  137.         pass
  138.  
  139.     def __mod__(self, y):
  140.         """ x.__mod__(y) <==> x%y """
  141.         pass
  142.  
  143.     def __mul__(self, y):
  144.         """ x.__mul__(y) <==> x*y """
  145.         pass
  146.  
  147.     def __neg__(self):
  148.         """ x.__neg__() <==> -x """
  149.         pass
  150.  
  151.     @staticmethod # known case of __new__
  152.     def __new__(S, *more):
  153.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  154.         pass
  155.  
  156.     def __nonzero__(self):
  157.         """ x.__nonzero__() <==> x != 0 """
  158.         pass
  159.  
  160.     def __oct__(self):
  161.         """ 返回改值的 八进制 表示 """
  162.         """ x.__oct__() <==> oct(x) """
  163.         pass
  164.  
  165.     def __or__(self, y):
  166.         """ x.__or__(y) <==> x|y """
  167.         pass
  168.  
  169.     def __pos__(self):
  170.         """ x.__pos__() <==> +x """
  171.         pass
  172.  
  173.     def __pow__(self, y, z=None):
  174.         """ 幂，次方 """
  175.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  176.         pass
  177.  
  178.     def __radd__(self, y):
  179.         """ x.__radd__(y) <==> y+x """
  180.         pass
  181.  
  182.     def __rand__(self, y):
  183.         """ x.__rand__(y) <==> y&x """
  184.         pass
  185.  
  186.     def __rdivmod__(self, y):
  187.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  188.         pass
  189.  
  190.     def __rdiv__(self, y):
  191.         """ x.__rdiv__(y) <==> y/x """
  192.         pass
  193.  
  194.     def __repr__(self):
  195.         """转化为解释器可读取的形式 """
  196.         """ x.__repr__() <==> repr(x) """
  197.         pass
  198.  
  199.     def __str__(self):
  200.         """转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""
  201.         """ x.__str__() <==> str(x) """
  202.         pass
  203.  
  204.     def __rfloordiv__(self, y):
  205.         """ x.__rfloordiv__(y) <==> y//x """
  206.         pass
  207.  
  208.     def __rlshift__(self, y):
  209.         """ x.__rlshift__(y) <==> y<<x """
  210.         pass
  211.  
  212.     def __rmod__(self, y):
  213.         """ x.__rmod__(y) <==> y%x """
  214.         pass
  215.  
  216.     def __rmul__(self, y):
  217.         """ x.__rmul__(y) <==> y*x """
  218.         pass
  219.  
  220.     def __ror__(self, y):
  221.         """ x.__ror__(y) <==> y|x """
  222.         pass
  223.  
  224.     def __rpow__(self, x, z=None):
  225.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  226.         pass
  227.  
  228.     def __rrshift__(self, y):
  229.         """ x.__rrshift__(y) <==> y>>x """
  230.         pass
  231.  
  232.     def __rshift__(self, y):
  233.         """ x.__rshift__(y) <==> x>>y """
  234.         pass
  235.  
  236.     def __rsub__(self, y):
  237.         """ x.__rsub__(y) <==> y-x """
  238.         pass
  239.  
  240.     def __rtruediv__(self, y):
  241.         """ x.__rtruediv__(y) <==> y/x """
  242.         pass
  243.  
  244.     def __rxor__(self, y):
  245.         """ x.__rxor__(y) <==> y^x """
  246.         pass
  247.  
  248.     def __sub__(self, y):
  249.         """ x.__sub__(y) <==> x-y """
  250.         pass
  251.  
  252.     def __truediv__(self, y):
  253.         """ x.__truediv__(y) <==> x/y """
  254.         pass
  255.  
  256.     def __trunc__(self, *args, **kwargs):
  257.         """ 返回数值被截取为整形的值，在整形中无意义 """
  258.         pass
  259.  
  260.     def __xor__(self, y):
  261.         """ x.__xor__(y) <==> x^y """
  262.         pass
  263.  
  264.     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  265.     """ 分母 = 1 """
  266.     """the denominator of a rational number in lowest terms"""
  267.  
  268.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  269.     """ 虚数，无意义 """
  270.     """the imaginary part of a complex number"""
  271.  
  272.     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  273.     """ 分子 = 数字大小 """
  274.     """the numerator of a rational number in lowest terms"""
  275.  
  276.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  277.     """ 实属，无意义 """
  278.     """the real part of a complex number"""
  279.  
  280. int

字符类型：不可变对象

字符串字面量：把文本放入单引号、双引号或三引号中，python2.x默认不是国际字符集unicode，需要unicode定义时加上u,python3无需加

  1. >>> str1 = u'hello world'
  2. >>> type(str1)
  3. unicode

文档字串：模块、类或函数的第一条语句是一个字符的话，该字符串就成为文档字符串，可以使用__doc__属性引用

  1. >>> def printName():
  2.        'test function'
  3.        print('hello world')
  4.  
  5. >>> printName.__doc__

适用于字符串常用方法：

  1. str.capitalize()    将字符串的首字母变大写
  2. str.upper()         将字符串变成大写
  3. str.lower()         将字符串变成小写
  4. str.index()         找出索引对应的字符串
  5. str.find()          同上
  6. str.format()        也是格式化的一种
  7. str.join()          以str为分隔符连接字符串
  8. str.strip()         将字符串两边中的空格去掉
  9. str.replace()       查找替换
  10. str.count()         找出字符串中元素出现的次数
  11. str.center()        以什么字符从字符串两边填充
  12. str.split()         以什么为分隔符分隔字符串
  13. str.title()         把每个单词的首字母变大写
  14. str.isupper()       判断是否为大写
  15. str.islower()       判断是否为小写
  16. str.isalnum()       判断是否是字母数字
  17. str.isalpha()       判断是否是字母下划线
  18. str.isdigit()       判断是否是数字
  19. str.isspace()       判断是否为空
  20. str.startswith()    找出以什么为开头的字符元素
  21. str.endswith()      找出以什么为结尾的字符元素

附上源码：

  1. class str(basestring):
  2.     """
  3.     str(object='') -> string
  4.  
  5.     Return a nice string representation of the object.
  6.     If the argument is a string, the return value is the same object.
  7.     """
  8.     def capitalize(self):
  9.         """ 首字母变大写 """
  10.         """
  11.         S.capitalize() -> string
  12.  
  13.         Return a copy of the string S with only its first character
  14.         capitalized.
  15.         """
  16.         return ""
  17.  
  18.     def center(self, width, fillchar=None):
  19.         """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
  20.         """
  21.         S.center(width[, fillchar]) -> string
  22.  
  23.         Return S centered in a string of length width. Padding is
  24.         done using the specified fill character (default is a space)
  25.         """
  26.         return ""
  27.  
  28.     def count(self, sub, start=None, end=None):
  29.         """ 子序列个数 """
  30.         """
  31.         S.count(sub[, start[, end]]) -> int
  32.  
  33.         Return the number of non-overlapping occurrences of substring sub in
  34.         string S[start:end].  Optional arguments start and end are interpreted
  35.         as in slice notation.
  36.         """
  37.         return 0
  38.  
  39.     def decode(self, encoding=None, errors=None):
  40.         """ 解码 """
  41.         """
  42.         S.decode([encoding[,errors]]) -> object
  43.  
  44.         Decodes S using the codec registered for encoding. encoding defaults
  45.         to the default encoding. errors may be given to set a different error
  46.         handling scheme. Default is 'strict' meaning that encoding errors raise
  47.         a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
  48.         as well as any other name registered with codecs.register_error that is
  49.         able to handle UnicodeDecodeErrors.
  50.         """
  51.         return object()
  52.  
  53.     def encode(self, encoding=None, errors=None):
  54.         """ 编码，针对unicode """
  55.         """
  56.         S.encode([encoding[,errors]]) -> object
  57.  
  58.         Encodes S using the codec registered for encoding. encoding defaults
  59.         to the default encoding. errors may be given to set a different error
  60.         handling scheme. Default is 'strict' meaning that encoding errors raise
  61.         a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
  62.         'xmlcharrefreplace' as well as any other name registered with
  63.         codecs.register_error that is able to handle UnicodeEncodeErrors.
  64.         """
  65.         return object()
  66.  
  67.     def endswith(self, suffix, start=None, end=None):
  68.         """ 是否以 xxx 结束 """
  69.         """
  70.         S.endswith(suffix[, start[, end]]) -> bool
  71.  
  72.         Return True if S ends with the specified suffix, False otherwise.
  73.         With optional start, test S beginning at that position.
  74.         With optional end, stop comparing S at that position.
  75.         suffix can also be a tuple of strings to try.
  76.         """
  77.         return False
  78.  
  79.     def expandtabs(self, tabsize=None):
  80.         """ 将tab转换成空格，默认一个tab转换成8个空格 """
  81.         """
  82.         S.expandtabs([tabsize]) -> string
  83.  
  84.         Return a copy of S where all tab characters are expanded using spaces.
  85.         If tabsize is not given, a tab size of 8 characters is assumed.
  86.         """
  87.         return ""
  88.  
  89.     def find(self, sub, start=None, end=None):
  90.         """ 寻找子序列位置，如果没找到，返回 -1 """
  91.         """
  92.         S.find(sub [,start [,end]]) -> int
  93.  
  94.         Return the lowest index in S where substring sub is found,
  95.         such that sub is contained within S[start:end].  Optional
  96.         arguments start and end are interpreted as in slice notation.
  97.  
  98.         Return -1 on failure.
  99.         """
  100.         return 0
  101.  
  102.     def format(*args, **kwargs): # known special case of str.format
  103.         """ 字符串格式化，动态参数，将函数式编程时细说 """
  104.         """
  105.         S.format(*args, **kwargs) -> string
  106.  
  107.         Return a formatted version of S, using substitutions from args and kwargs.
  108.         The substitutions are identified by braces ('{' and '}').
  109.         """
  110.         pass
  111.  
  112.     def index(self, sub, start=None, end=None):
  113.         """ 子序列位置，如果没找到，报错 """
  114.         S.index(sub [,start [,end]]) -> int
  115.  
  116.         Like S.find() but raise ValueError when the substring is not found.
  117.         """
  118.         return 0
  119.  
  120.     def isalnum(self):
  121.         """ 是否是字母和数字 """
  122.         """
  123.         S.isalnum() -> bool
  124.  
  125.         Return True if all characters in S are alphanumeric
  126.         and there is at least one character in S, False otherwise.
  127.         """
  128.         return False
  129.  
  130.     def isalpha(self):
  131.         """ 是否是字母 """
  132.         """
  133.         S.isalpha() -> bool
  134.  
  135.         Return True if all characters in S are alphabetic
  136.         and there is at least one character in S, False otherwise.
  137.         """
  138.         return False
  139.  
  140.     def isdigit(self):
  141.         """ 是否是数字 """
  142.         """
  143.         S.isdigit() -> bool
  144.  
  145.         Return True if all characters in S are digits
  146.         and there is at least one character in S, False otherwise.
  147.         """
  148.         return False
  149.  
  150.     def islower(self):
  151.         """ 是否小写 """
  152.         """
  153.         S.islower() -> bool
  154.  
  155.         Return True if all cased characters in S are lowercase and there is
  156.         at least one cased character in S, False otherwise.
  157.         """
  158.         return False
  159.  
  160.     def isspace(self):
  161.         """
  162.         S.isspace() -> bool
  163.  
  164.         Return True if all characters in S are whitespace
  165.         and there is at least one character in S, False otherwise.
  166.         """
  167.         return False
  168.  
  169.     def istitle(self):
  170.         """
  171.         S.istitle() -> bool
  172.  
  173.         Return True if S is a titlecased string and there is at least one
  174.         character in S, i.e. uppercase characters may only follow uncased
  175.         characters and lowercase characters only cased ones. Return False
  176.         otherwise.
  177.         """
  178.         return False
  179.  
  180.     def isupper(self):
  181.         """
  182.         S.isupper() -> bool
  183.  
  184.         Return True if all cased characters in S are uppercase and there is
  185.         at least one cased character in S, False otherwise.
  186.         """
  187.         return False
  188.  
  189.     def join(self, iterable):
  190.         """ 连接 """
  191.         """
  192.         S.join(iterable) -> string
  193.  
  194.         Return a string which is the concatenation of the strings in the
  195.         iterable.  The separator between elements is S.
  196.         """
  197.         return ""
  198.  
  199.     def ljust(self, width, fillchar=None):
  200.         """ 内容左对齐，右侧填充 """
  201.         """
  202.         S.ljust(width[, fillchar]) -> string
  203.  
  204.         Return S left-justified in a string of length width. Padding is
  205.         done using the specified fill character (default is a space).
  206.         """
  207.         return ""
  208.  
  209.     def lower(self):
  210.         """ 变小写 """
  211.         """
  212.         S.lower() -> string
  213.  
  214.         Return a copy of the string S converted to lowercase.
  215.         """
  216.         return ""
  217.  
  218.     def lstrip(self, chars=None):
  219.         """ 移除左侧空白 """
  220.         """
  221.         S.lstrip([chars]) -> string or unicode
  222.  
  223.         Return a copy of the string S with leading whitespace removed.
  224.         If chars is given and not None, remove characters in chars instead.
  225.         If chars is unicode, S will be converted to unicode before stripping
  226.         """
  227.         return ""
  228.  
  229.     def partition(self, sep):
  230.         """ 分割，前，中，后三部分 """
  231.         """
  232.         S.partition(sep) -> (head, sep, tail)
  233.  
  234.         Search for the separator sep in S, and return the part before it,
  235.         the separator itself, and the part after it.  If the separator is not
  236.         found, return S and two empty strings.
  237.         """
  238.         pass
  239.  
  240.     def replace(self, old, new, count=None):
  241.         """ 替换 """
  242.         """
  243.         S.replace(old, new[, count]) -> string
  244.  
  245.         Return a copy of string S with all occurrences of substring
  246.         old replaced by new.  If the optional argument count is
  247.         given, only the first count occurrences are replaced.
  248.         """
  249.         return ""
  250.  
  251.     def rfind(self, sub, start=None, end=None):
  252.         """
  253.         S.rfind(sub [,start [,end]]) -> int
  254.  
  255.         Return the highest index in S where substring sub is found,
  256.         such that sub is contained within S[start:end].  Optional
  257.         arguments start and end are interpreted as in slice notation.
  258.  
  259.         Return -1 on failure.
  260.         """
  261.         return 0
  262.  
  263.     def rindex(self, sub, start=None, end=None):
  264.         """
  265.         S.rindex(sub [,start [,end]]) -> int
  266.  
  267.         Like S.rfind() but raise ValueError when the substring is not found.
  268.         """
  269.         return 0
  270.  
  271.     def rjust(self, width, fillchar=None):
  272.         """
  273.         S.rjust(width[, fillchar]) -> string
  274.  
  275.         Return S right-justified in a string of length width. Padding is
  276.         done using the specified fill character (default is a space)
  277.         """
  278.         return ""
  279.  
  280.     def rpartition(self, sep):
  281.         """
  282.         S.rpartition(sep) -> (head, sep, tail)
  283.  
  284.         Search for the separator sep in S, starting at the end of S, and return
  285.         the part before it, the separator itself, and the part after it.  If the
  286.         separator is not found, return two empty strings and S.
  287.         """
  288.         pass
  289.  
  290.     def rsplit(self, sep=None, maxsplit=None):
  291.         """
  292.         S.rsplit([sep [,maxsplit]]) -> list of strings
  293.  
  294.         Return a list of the words in the string S, using sep as the
  295.         delimiter string, starting at the end of the string and working
  296.         to the front.  If maxsplit is given, at most maxsplit splits are
  297.         done. If sep is not specified or is None, any whitespace string
  298.         is a separator.
  299.         """
  300.         return []
  301.  
  302.     def rstrip(self, chars=None):
  303.         """
  304.         S.rstrip([chars]) -> string or unicode
  305.  
  306.         Return a copy of the string S with trailing whitespace removed.
  307.         If chars is given and not None, remove characters in chars instead.
  308.         If chars is unicode, S will be converted to unicode before stripping
  309.         """
  310.         return ""
  311.  
  312.     def split(self, sep=None, maxsplit=None):
  313.         """ 分割， maxsplit最多分割几次 """
  314.         """
  315.         S.split([sep [,maxsplit]]) -> list of strings
  316.  
  317.         Return a list of the words in the string S, using sep as the
  318.         delimiter string.  If maxsplit is given, at most maxsplit
  319.         splits are done. If sep is not specified or is None, any
  320.         whitespace string is a separator and empty strings are removed
  321.         from the result.
  322.         """
  323.         return []
  324.  
  325.     def splitlines(self, keepends=False):
  326.         """ 根据换行分割 """
  327.         """
  328.         S.splitlines(keepends=False) -> list of strings
  329.  
  330.         Return a list of the lines in S, breaking at line boundaries.
  331.         Line breaks are not included in the resulting list unless keepends
  332.         is given and true.
  333.         """
  334.         return []
  335.  
  336.     def startswith(self, prefix, start=None, end=None):
  337.         """ 是否起始 """
  338.         """
  339.         S.startswith(prefix[, start[, end]]) -> bool
  340.  
  341.         Return True if S starts with the specified prefix, False otherwise.
  342.         With optional start, test S beginning at that position.
  343.         With optional end, stop comparing S at that position.
  344.         prefix can also be a tuple of strings to try.
  345.         """
  346.         return False
  347.  
  348.     def strip(self, chars=None):
  349.         """ 移除两段空白 """
  350.         """
  351.         S.strip([chars]) -> string or unicode
  352.  
  353.         Return a copy of the string S with leading and trailing
  354.         whitespace removed.
  355.         If chars is given and not None, remove characters in chars instead.
  356.         If chars is unicode, S will be converted to unicode before stripping
  357.         """
  358.         return ""
  359.  
  360.     def swapcase(self):
  361.         """ 大写变小写，小写变大写 """
  362.         """
  363.         S.swapcase() -> string
  364.  
  365.         Return a copy of the string S with uppercase characters
  366.         converted to lowercase and vice versa.
  367.         """
  368.         return ""
  369.  
  370.     def title(self):
  371.         """
  372.         S.title() -> string
  373.  
  374.         Return a titlecased version of S, i.e. words start with uppercase
  375.         characters, all remaining cased characters have lowercase.
  376.         """
  377.         return ""
  378.  
  379.     def translate(self, table, deletechars=None):
  380.         """
  381.         转换，需要先做一个对应表，最后一个表示删除字符集合
  382.         intab = "aeiou"
  383.         outtab = ""
  384.         trantab = maketrans(intab, outtab)
  385.         str = "this is string example....wow!!!"
  386.         print str.translate(trantab, 'xm')
  387.         """
  388.  
  389.         """
  390.         S.translate(table [,deletechars]) -> string
  391.  
  392.         Return a copy of the string S, where all characters occurring
  393.         in the optional argument deletechars are removed, and the
  394.         remaining characters have been mapped through the given
  395.         translation table, which must be a string of length 256 or None.
  396.         If the table argument is None, no translation is applied and
  397.         the operation simply removes the characters in deletechars.
  398.         """
  399.         return ""
  400.  
  401.     def upper(self):
  402.         """
  403.         S.upper() -> string
  404.  
  405.         Return a copy of the string S converted to uppercase.
  406.         """
  407.         return ""
  408.  
  409.     def zfill(self, width):
  410.         """方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""
  411.         """
  412.         S.zfill(width) -> string
  413.  
  414.         Pad a numeric string S with zeros on the left, to fill a field
  415.         of the specified width.  The string S is never truncated.
  416.         """
  417.         return ""
  418.  
  419.     def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
  420.         pass
  421.  
  422.     def _formatter_parser(self, *args, **kwargs): # real signature unknown
  423.         pass
  424.  
  425.     def __add__(self, y):
  426.         """ x.__add__(y) <==> x+y """
  427.         pass
  428.  
  429.     def __contains__(self, y):
  430.         """ x.__contains__(y) <==> y in x """
  431.         pass
  432.  
  433.     def __eq__(self, y):
  434.         """ x.__eq__(y) <==> x==y """
  435.         pass
  436.  
  437.     def __format__(self, format_spec):
  438.         """
  439.         S.__format__(format_spec) -> string
  440.  
  441.         Return a formatted version of S as described by format_spec.
  442.         """
  443.         return ""
  444.  
  445.     def __getattribute__(self, name):
  446.         """ x.__getattribute__('name') <==> x.name """
  447.         pass
  448.  
  449.     def __getitem__(self, y):
  450.         """ x.__getitem__(y) <==> x[y] """
  451.         pass
  452.  
  453.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  454.         pass
  455.  
  456.     def __getslice__(self, i, j):
  457.         """
  458.         x.__getslice__(i, j) <==> x[i:j]
  459.  
  460.                    Use of negative indices is not supported.
  461.         """
  462.         pass
  463.  
  464.     def __ge__(self, y):
  465.         """ x.__ge__(y) <==> x>=y """
  466.         pass
  467.  
  468.     def __gt__(self, y):
  469.         """ x.__gt__(y) <==> x>y """
  470.         pass
  471.  
  472.     def __hash__(self):
  473.         """ x.__hash__() <==> hash(x) """
  474.         pass
  475.  
  476.     def __init__(self, string=''): # known special case of str.__init__
  477.         """
  478.         str(object='') -> string
  479.  
  480.         Return a nice string representation of the object.
  481.         If the argument is a string, the return value is the same object.
  482.         # (copied from class doc)
  483.         """
  484.         pass
  485.  
  486.     def __len__(self):
  487.         """ x.__len__() <==> len(x) """
  488.         pass
  489.  
  490.     def __le__(self, y):
  491.         """ x.__le__(y) <==> x<=y """
  492.         pass
  493.  
  494.     def __lt__(self, y):
  495.         """ x.__lt__(y) <==> x<y """
  496.         pass
  497.  
  498.     def __mod__(self, y):
  499.         """ x.__mod__(y) <==> x%y """
  500.         pass
  501.  
  502.     def __mul__(self, n):
  503.         """ x.__mul__(n) <==> x*n """
  504.         pass
  505.  
  506.     @staticmethod # known case of __new__
  507.     def __new__(S, *more):
  508.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  509.         pass
  510.  
  511.     def __ne__(self, y):
  512.         """ x.__ne__(y) <==> x!=y """
  513.         pass
  514.  
  515.     def __repr__(self):
  516.         """ x.__repr__() <==> repr(x) """
  517.         pass
  518.  
  519.     def __rmod__(self, y):
  520.         """ x.__rmod__(y) <==> y%x """
  521.         pass
  522.  
  523.     def __rmul__(self, n):
  524.         """ x.__rmul__(n) <==> n*x """
  525.         pass
  526.  
  527.     def __sizeof__(self):
  528.         """ S.__sizeof__() -> size of S in memory, in bytes """
  529.         pass
  530.  
  531.     def __str__(self):
  532.         """ x.__str__() <==> str(x) """
  533.         pass

列表类型：可变对象

表达式符号：[]

创建列表：

  1. name_list = ['alex', 'seven', 'eric']
  2. 或
  3. name_list ＝ list(['alex', 'seven', 'eric'])

容器类型
　　任意对象的有序集合，通过索引访问其中的元素，可变对象
　　异构混合类型，可以任意嵌套其它类型

支持在原处修改：
　　修改指定的索引元素，修改指定的分片，删除语句，类的内置方法

适用于列表常用方法：

  1. list.append()    在列表尾部插入
  2. list.copy()      浅复制,只会复制第一层,如果有嵌套序列则不会复制,如果需要复制则要导入copy模块
  3. list.count()     统计列表中元素的次数
  4. list.extend()    把另外一个列表合并，并不是追加
  5. list.index()     列表中元素出现的索引位置
  6. list.insert()    在列表中指定索引位置前插入元素
  7. list.pop()       没有指定索引，则弹出最后一个元素，返回的结果是弹出的索引对应的元素
  8. list.remove()    删除指定的元素
  9. list.reverse()   进行逆序
  10. list.sort()      进行排序,python3无法把数字和字符串一起排序
  11. l1 + l2 :  合并两个列表，返回一个新的列表，不会修改原列表
  12. l1 * N :   把l1重复N次，返回一个新列表

附上源码：

  1. class list(object):
  2.     """
  3.     list() -> new empty list
  4.     list(iterable) -> new list initialized from iterable's items
  5.     """
  6.     def append(self, p_object): # real signature unknown; restored from __doc__
  7.         """ L.append(object) -- append object to end """
  8.         pass
  9.  
  10.     def count(self, value): # real signature unknown; restored from __doc__
  11.         """ L.count(value) -> integer -- return number of occurrences of value """
  12.         return 0
  13.  
  14.     def extend(self, iterable): # real signature unknown; restored from __doc__
  15.         """ L.extend(iterable) -- extend list by appending elements from the iterable """
  16.         pass
  17.  
  18.     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  19.         """
  20.         L.index(value, [start, [stop]]) -> integer -- return first index of value.
  21.         Raises ValueError if the value is not present.
  22.         """
  23.         return 0
  24.  
  25.     def insert(self, index, p_object): # real signature unknown; restored from __doc__
  26.         """ L.insert(index, object) -- insert object before index """
  27.         pass
  28.  
  29.     def pop(self, index=None): # real signature unknown; restored from __doc__
  30.         """
  31.         L.pop([index]) -> item -- remove and return item at index (default last).
  32.         Raises IndexError if list is empty or index is out of range.
  33.         """
  34.         pass
  35.  
  36.     def remove(self, value): # real signature unknown; restored from __doc__
  37.         """
  38.         L.remove(value) -- remove first occurrence of value.
  39.         Raises ValueError if the value is not present.
  40.         """
  41.         pass
  42.  
  43.     def reverse(self): # real signature unknown; restored from __doc__
  44.         """ L.reverse() -- reverse *IN PLACE* """
  45.         pass
  46.  
  47.     def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
  48.         """
  49.         L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
  50.         cmp(x, y) -> -1, 0, 1
  51.         """
  52.         pass
  53.  
  54.     def __add__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__add__(y) <==> x+y """
  56.         pass
  57.  
  58.     def __contains__(self, y): # real signature unknown; restored from __doc__
  59.         """ x.__contains__(y) <==> y in x """
  60.         pass
  61.  
  62.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  63.         """ x.__delitem__(y) <==> del x[y] """
  64.         pass
  65.  
  66.     def __delslice__(self, i, j): # real signature unknown; restored from __doc__
  67.         """
  68.         x.__delslice__(i, j) <==> del x[i:j]
  69.  
  70.                    Use of negative indices is not supported.
  71.         """
  72.         pass
  73.  
  74.     def __eq__(self, y): # real signature unknown; restored from __doc__
  75.         """ x.__eq__(y) <==> x==y """
  76.         pass
  77.  
  78.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  79.         """ x.__getattribute__('name') <==> x.name """
  80.         pass
  81.  
  82.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  83.         """ x.__getitem__(y) <==> x[y] """
  84.         pass
  85.  
  86.     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  87.         """
  88.         x.__getslice__(i, j) <==> x[i:j]
  89.  
  90.                    Use of negative indices is not supported.
  91.         """
  92.         pass
  93.  
  94.     def __ge__(self, y): # real signature unknown; restored from __doc__
  95.         """ x.__ge__(y) <==> x>=y """
  96.         pass
  97.  
  98.     def __gt__(self, y): # real signature unknown; restored from __doc__
  99.         """ x.__gt__(y) <==> x>y """
  100.         pass
  101.  
  102.     def __iadd__(self, y): # real signature unknown; restored from __doc__
  103.         """ x.__iadd__(y) <==> x+=y """
  104.         pass
  105.  
  106.     def __imul__(self, y): # real signature unknown; restored from __doc__
  107.         """ x.__imul__(y) <==> x*=y """
  108.         pass
  109.  
  110.     def __init__(self, seq=()): # known special case of list.__init__
  111.         """
  112.         list() -> new empty list
  113.         list(iterable) -> new list initialized from iterable's items
  114.         # (copied from class doc)
  115.         """
  116.         pass
  117.  
  118.     def __iter__(self): # real signature unknown; restored from __doc__
  119.         """ x.__iter__() <==> iter(x) """
  120.         pass
  121.  
  122.     def __len__(self): # real signature unknown; restored from __doc__
  123.         """ x.__len__() <==> len(x) """
  124.         pass
  125.  
  126.     def __le__(self, y): # real signature unknown; restored from __doc__
  127.         """ x.__le__(y) <==> x<=y """
  128.         pass
  129.  
  130.     def __lt__(self, y): # real signature unknown; restored from __doc__
  131.         """ x.__lt__(y) <==> x<y """
  132.         pass
  133.  
  134.     def __mul__(self, n): # real signature unknown; restored from __doc__
  135.         """ x.__mul__(n) <==> x*n """
  136.         pass
  137.  
  138.     @staticmethod # known case of __new__
  139.     def __new__(S, *more): # real signature unknown; restored from __doc__
  140.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  141.         pass
  142.  
  143.     def __ne__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__ne__(y) <==> x!=y """
  145.         pass
  146.  
  147.     def __repr__(self): # real signature unknown; restored from __doc__
  148.         """ x.__repr__() <==> repr(x) """
  149.         pass
  150.  
  151.     def __reversed__(self): # real signature unknown; restored from __doc__
  152.         """ L.__reversed__() -- return a reverse iterator over the list """
  153.         pass
  154.  
  155.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  156.         """ x.__rmul__(n) <==> n*x """
  157.         pass
  158.  
  159.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  160.         """ x.__setitem__(i, y) <==> x[i]=y """
  161.         pass
  162.  
  163.     def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
  164.         """
  165.         x.__setslice__(i, j, y) <==> x[i:j]=y
  166.  
  167.                    Use  of negative indices is not supported.
  168.         """
  169.         pass
  170.  
  171.     def __sizeof__(self): # real signature unknown; restored from __doc__
  172.         """ L.__sizeof__() -- size of L in memory, in bytes """
  173.         pass
  174.  
  175.     __hash__ = None

字典类型：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])

字典中常用的方法：

  1. 适用于字典常用方法：
  2. dict.clear()       清除字典中所有元素
  3. dict.copy()        字典复制，d2 = d1.copy(),是浅复制,如果深复制需要copy模块
  4. dict.fromkeys(S)   生成一个新字典
  5. dict.get(key)      取得某个key的value
  6. dict.has_key(key)  判断字典是否有这个key
  7. dict.items()       将字典的键值拆成元组，全部元组组成一个列表
  8. dict.keys()        返回所有的key为一个列表
  9. dict.values()      返回所有的value为一个列表
  10. dict.pop(key)      弹出某个key-value
  11. dict.popitem()     随机弹出key-value
  12. dict.update(key)   将一个字典合并到当前字典中
  13. dict.iteritems()   生成key-value迭代器，可以用next()取下个key-value
  14. dict.iterkeys()    生成key迭代器
  15. dict.itervalues()  生成values迭代器

元组类型：不可变对象

表达式符号：()

创建元组：

ages = (11, 22, 33, 44, 55)

或

ages = tuple((11, 22, 33, 44, 55))

容器类型

　　任意对象的有序集合，通过索引访问其中的元素，不可变对象
　　异构混合类型，可以任意嵌套其它类型
　　虽然元组本身不可变，但如果元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组

　　(): 空元组
　　(1,): 单个元组需要尾部加上逗号，如果元素是数字没有加逗号则不是元组
　　(1,2): 多元素元组
　　1,2,3,4: 在定义变量时没有加上小括号，默认是元组，最好不建议使用

适用于元组常用方法：

tuple.count() 统计元组中元素的个数

tuple.index() 找出元组中元素的索引位置

Python 基础 一的更多相关文章

  1. python之最强王者（2）——python基础语法

    背景介绍:由于本人一直做java开发,也是从txt开始写hello,world,使用javac命令编译,一直到使用myeclipse,其中的道理和辛酸都懂(请容许我擦干眼角的泪水),所以对于pytho ...

  2. Python开发【第二篇】：Python基础知识

    Python基础知识 一.初识基本数据类型 类型: int(整型) 在32位机器上,整数的位数为32位,取值范围为-2**31-2**31-1,即-2147483648-2147483647 在64位 ...

  3. Python小白的发展之路之Python基础（一）

    Python基础部分1: 1.Python简介 2.Python 2 or 3,两者的主要区别 3.Python解释器 4.安装Python 5.第一个Python程序 Hello World 6.P ...

  4. Python之路3【第一篇】Python基础

    本节内容 Python简介 Python安装 第一个Python程序 编程语言的分类 Python简介 1.Python的由来 python的创始人为吉多·范罗苏姆(Guido van Rossum) ...

  5. 进击的Python【第三章】：Python基础(三)

    Python基础(三) 本章内容 集合的概念与操作 文件的操作 函数的特点与用法 参数与局部变量 return返回值的概念 递归的基本含义 函数式编程介绍 高阶函数的概念 一.集合的概念与操作 集合( ...

  6. 进击的Python【第二章】：Python基础(二)

    Python基础(二) 本章内容 数据类型 数据运算 列表与元组的基本操作 字典的基本操作 字符编码与转码 模块初探 练习:购物车程序 一.数据类型 Python有五个标准的数据类型: Numbers ...

  7. Python之路【第一篇】python基础

    一.python开发 1.开发: 1)高级语言:python .Java .PHP. C#  Go ruby  c++  ===>字节码 2)低级语言:c .汇编 2.语言之间的对比: 1)py ...

  8. python基础之day1

    Python 简介 Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言. Python为我们提供了非常完善的基础代码库,覆盖了 ...

  9. python基础之文件读写

    python基础之文件读写 本节内容 os模块中文件以及目录的一些方法 文件的操作 目录的操作 1.os模块中文件以及目录的一些方法 python操作文件以及目录可以使用os模块的一些方法如下: 得到 ...

  10. python基础之编码问题

    python基础之编码问题 本节内容 字符串编码问题由来 字符串编码解决方案 1.字符串编码问题由来 由于字符串编码是从ascii--->unicode--->utf-8(utf-16和u ...

随机推荐

  1. iOS最好用的弹出框

    重构项目时发现有的时候需要弹出提示,比如登录成功,数据请求失败,还有选择相机或者相册来上传头像等等. 今天就自己写了一个弹出框,采用的是系统的UIAlertController,只不过自己有定义了一些 ...

  2. Solr commit 策略测试

    已知Solr 的Commit策略: 服务器端: 1)AutoCommit 2)AutoSoftCommit 客户端 Commit 本次我测试了客户端关闭Commit的情况下,服务器端Commit策略的 ...

  3. Ionic android 底部tabs

    ionic android tabs 默认显示在上部,如果要跟苹果一起统一在底部,那么可以在app.js添加配置 .config(function($ionicConfigProvider) { $i ...

  4. redux三个基本原则

    (1)单一数据源:整个应用的state被存储在一棵object tree中,并且这个object tree只存在于唯一一个store中: (2)state是只读的:唯一改变state的方法就是触发ac ...

  5. CoreAnimation 目录

    CoreAnimation 目录 CoreAnimation 开篇 CoreAnimation 寄宿图 CoreAnimation 图层几何学 CoreAnimation 视觉效果

  6. python实现TCP/UDP通信

    一.说明 对于TCP/udp的说明已经很多了,我在这里只是简单的说明一下 二.套接字scoket 套接字是一种具有之前所说的"通信端点"概念的计算网络数据结构.相当于电话插口,没它 ...

  7. QQGame防专线中断系统介绍

    先说说背景 QQGame是一个全区全服的休闲类游戏平台和社区,主逻辑服务器部署在四大IDC,核心DB全部在深圳.对跨IDC的专线依赖度很高. 网平提供专线故障后切VPN的备份机制,当VPN也中断时QQ ...

  8. Redis构建分布式锁

    1.前言 为什么要构建锁呢?因为构建合适的锁可以在高并发下能够保持数据的一致性,即客户端在执行连贯的命令时上锁的数据不会被别的客户端的更改而发生错误.同时还能够保证命令执行的成功率. 看到这里你不禁要 ...

  9. Zkui安装

    是一个允许在zookeeper上进行增删查改操作的图形管理工具,与zkdash类似. 1.拉取代码 #git clone https://github.com/DeemOpen/zkui.git 2. ...

  10. javascript的闭包与一次重构的感受

    有没有这么一个场景,你的一个动作需要在所有异步方法执行完毕后,再进行操作?然而你对异步方法何时执行完毕感到困扰,只能在每个方法中写回调,在回调中重复劳动? 偶然的,想起了之前经理讲过的闭包的概念,偶然 ...