Python学习笔记 第1章 基础知识

    # pip freeze [> 保存文件名.txt]
    pip freeze [> xxx.txt]
    # 列出已安装的所有包
    pip list

    # pip install 模块名[==版本号]
    pip install xxx[==version]

    # pip install 模块名.whl   //事先要把模块放到对应的scripts文件夹中
    pip install D:xxx.whl

    #pip install -r 包含扩展库信息的文本.txt
    pip install -r xxx.txt

    #pip install --upgrade 模块名
    pip install xxx
    # 批量升级库，先安装pip-review，在升级
    pip install pip-review
    pip-review --local --interactive

    python -m pip install --upgrade pip

    pip  list --outdated

    # 零时安装 pip install 模块名 -i 源地址 --trusted-host 主机地址
    # --trusted-host 主机地址是为了防止出现不信任源
    pip install jieba -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
    
    # 长期更换源地址
    # 直接在user目录中创建一个pip目录，如：C:\Users\xx\pip
    # 新建文件 pip.ini 
    # 内容为
    
    [global]
    index-url = http://mirrors.aliyun.com/pypi/simple/
    trusted-host = mirrors.aliyun.com
    disable-pip-version-check = true
    timeout = 120
    
    # http://mirrors.aliyun.com/pypi/simple/ //阿里
    # https://pypi.tuna.tsinghua.edu.cn/simple/ //清华
    # http://pypi.douban.com/ //豆瓣
    # http://pypi.hustunique.com/ //华中理工大学
    # http://pypi.sdutlinux.org/ //山东理工大学
    # http://pypi.mirrors.ustc.edu.cn/ //中国科学技术大学

    pip install jieba --user

    python -V

    dir(__builtins__)

    >>> x = 3       #创建整型变量
    >>> print(x**2)
    9
    
    >>> x += 6      #修改变量值
    >>> print(x)    #读取变量值并输出显示
    9
    
    >>> x = [1,2,3] #创建列表对象
    >>> x[1] = 5    #修改列表元素值
    >>> print(x)    #输出显示整个列表
    [1, 5, 3]
    >>> print(x[2]) #输出显示列表指定元素
    3

    >>> x = 3
    >>> id(x)  # 获取x的地址
    1786684560
    >>> y = x  # x的值赋给y
    >>> id(y)  # 获取x的地址
    1786684560  
    # x和y指向同一个内存地址

    >>> x = -6
    >>> y = -6
    >>> id(x)==id(y)  
    False                # 范围超过【-5，256】且没有在同一语句
    >>> x = -5
    >>> y = -5
    >>> id(x) == id(y)
    True				 # 在【-5，256】之间，虽然没在同一语句，依旧共用
    >>> x = 255
    >>> y = 255
    >>> id(x) == id(y)
    True				 # 在【-5，256】之间，虽然没在同一语句，依旧共用
    >>> x = 256
    >>> y = 256
    >>> id(x) == id(y)
    True				 # 在【-5，256】之间，虽然没在同一语句，依旧共用
    
    
    >>> x = 257
    >>> y = 257
    >>> id(x) == id(y)
    False 				 # 范围超过【-5，256】且没有在同一语句
    >>> x = 3.0
    >>> y = 3.0
    >>> id(x) == id(y)   # 在【-5，256】之间，但是浮点数，不是整数
    False
    >>> x, y = 300000, 300000
    >>> id(x) == id(y)
    True				 # 范围超过【-5，256】但是在同一语句
    >>> x = [666666, 666666]
    >>> y = (666666, 666666)
    >>> id(x[0]) == id(x[1])
    True				 # 范围超过【-5，256】但是在同一语句
    >>> id(y[0]) == id(y[1])
    True   				 # 范围超过【-5，256】但是在同一语句
    >>> id(x[0]) == id(y[0])
    False  				 # 范围超过【-5，256】且没有在同一语句

    x = 30000000000
    y = 30000000000
    print(id(x)==id(y))  # True  同一文件内，相同的数都会共用内存地址
    x = 3.4
    y = 3.4
    print(id(x)==id(y))	 # True  同一文件内，相同的数都会共用内存地址

    >>> import sys 								# 引入sys模块
    >>> sys.getrefcount(2)						# sys.getrefcount(对象) 查看引用次数
    77
    >>> x = 2     								# x指向2
    >>> sys.getrefcount(2)						# 再查看2的引用次数加一
    78
    >>> del(x)									# x不再指向2
    >>> sys.getrefcount(2)						# 查看2的引用次数减一
    77
    >>> x										# 再通过x已经无法访问到2
    Traceback (most recent call last):			
      File "<stdin>", line 1, in <module>
    NameError: name 'x' is not defined

   * 单前导下划线_：下划线前缀的含义是告知其他程序员：以单个下划线开头的变量或方法仅供内部使用。_
   * _单末尾下划线_ ：单个末尾下划线（后缀）是一个约定，用来避免与Python关键字产生命名冲突。
   * 双前导下划线 __：双下划线前缀会导致Python解释器重写属性名称，以避免子类中的命名冲突（名称修饰），变成“_类名__变量名”格式。
   * 双前导和双末尾下划线__：如果一个名字同时以双下划线开始和结束，则不会应用名称修饰。 由双下划线前缀和后缀包围的变量不会被Python解释器修改。主要是特殊用途
   * 单下划线 _：单个独立下划线是用作一个名字，来表示某个变量是临时的或无关紧要的。在交互模式下也表示最近一个表达式的值（成功）

    >>> import keyword

    >>> print(keyword.kwlist)

10. 

    >>> a = 99
    >>> a ** a
    369729637649726772657187905628805440595668764281741102430259972423552570455277523421410650010128232727940978889548326540119429996769494359451621570193644014418071060667659301384999779999159200499899

 * **十进制整数** : 如，0、-1、9、123
 * **十六进制整数** : 需要16个数字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f来表示整数，必须以0x开头，如0x10、0xfa、0xabcdef (a、b、c、d、e、f可以大写或者小写)
 * **八进制整数** ，只需要8个数字0、1、2、3、4、5、6、7来表示整数，必须以0o开头，如0o35、0o11
 * **二进制整数** ，只需要2个数字0、1来表示整数，必须以0b开头如，0b101、0b100

    >>> oct(80) # 十进制到八进制

    '0o120'
    >>> bin(80) # 十进制到二进制
    '0b1010000'
    >>> hex(80) # 十进制到十六进制
    '0x50'

    >>> int("637270012", base=8)        # 八进制到十进制

    108883978
    >>> int("0o637270012", base=8)    # 八进制到十进制
    108883978
    >>> int("637270012", base=16)     # 十六进制到十进制
    26695106578

    >>> x = eval('0b1010')

    >>> x
    10
    # eval() 函数的作用是去掉字符串最外层的引号，详细用法后面会讲到

    >>> 1_000_000

    1000000
    >>> 1_2_3_4
    1234
    >>> 1_2 + 3_4j
    (12+34j)
    >>> 1_2.3_45
    12.345

    >>> x=float("Infinity")

    >>> x
    inf

    >>> x=float("nan")

    >>> x
    nan    # 不是一个数

    >>> a = 3+4j
    >>> b = 5+6j
    >>> c = a+b
    >>> c
    (8+10j)
    >>> c.real        #查看复数实部
    8.0
    >>> c.imag        #查看复数虚部
    10.0
    >>> a.conjugate() #返回共轭复数
    (3-4j)
    >>> a * b           #复数乘法
    (-9+38j)
    >>> a / b           #复数除法
    (0.6393442622950819+0.03278688524590165j)

    >>> int(3.2)

    3
    >>> float(3)
    3.0
    >>> complex(3)
    (3+0j)
    >>> complex(1,2)
    (1+2j)

    'abc'、'123'、'中国'、"Python"、'''Tom said, "Let's go"'''

    >>> path = 'C:\Windows\notepad.exe'

    >>> print(path)                        #字符\n被转义为换行符
    C:\Windows
    otepad.exe
    
    >>> path = r'C:\Windows\notepad.exe'   #原始字符串，任何字符都不转义
    >>> print(path)
    C:\Windows\notepad.exe
    
    >>> x=r"assd\"						   # 报错
      File "<stdin>", line 1
    x=r"assd\"
             ^
    SyntaxError: EOL while scanning string literal
    >>> x=r"assd\ " 
    >>> x
    'assd\ \ '            				   # 四个杠

 * str() 函数，它会把值转换为合理形式的字符串
 * repr()，将值转换为合法的python表达式

    >>> print(str("Hello, world!"))

    Hello, world!
    >>> print(str(10000))             # str()函数会把参数转换成合理的字符串，通常字符串不包含引号
    10000
    
    >>>s = 'RUNOOB'					  # repr()函数不会考虑合理性，直接在最外层加引号
    >>> repr(s)
    "'RUNOOB'"
    >>> str(s) 
    'RUNOOB'
    >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
    >>> repr(dict)
    "{'google': 'google.com', 'runoob': 'runoob.com'}"

    >>> 20+5

    25
    >>> 4.1+4.2
    8.3
    >>> 4.1+4.3
    8.399999999999999			# 存储精度不足

    >>> [1, 2, 3] + [4, 5, 6]          #连接两个列表

    [1, 2, 3, 4, 5, 6]
    >>> (1, 2, 3) + (4,)               #连接两个元组
    (1, 2, 3, 4)
    >>> 'abcd' + '1234'                #连接两个字符串
    'abcd1234'
    >>> 'A' + 1                        #不支持字符与数字相加，抛出异常
      File "<stdin>", line 1, in <module>
    TypeError: can only concatenate str (not "int") to str
        
    >>> True + 3                       #Python内部把True当作1处理
    4
    >>> False + 3                      #把False当作0处理

    >>> 25-5

    20
    >>> 5-True
    4
    >>> 4.3-2.1
    2.1999999999999997              # 精度不足

    >>> {1,2,3,4} - {2,4,7,8,}

    {1, 3}         # 在第一个集合中，排除掉第二个集合中所包含的元素

    >>> 2.0 * 3                     #浮点数与整数相乘

    6.0
    >>> (3+4j) * 2                  #复数与整数相乘
    (6+8j)
    >>> (3+4j) * (3-4j)             #复数与复数相乘
    (25+0j)
    >>> "a" * 10                    #字符串重复
    'aaaaaaaaaa'
    >>>[1,[1,2],3]*3          	    #列表重复
    [1, [1, 2], 3, 1, [1, 2], 3, 1, [1, 2], 3]
    >>> (1,2,[3])*3                 #元组重复
    (1, 2, [3], 1, 2, [3], 1, 2, [3])

    >>> 3 / 5

    0.6
    >>> 3 // 5
    0
    >>> 3.0 / 5
    0.6
    >>> 3.0 // 5
    0.0
    >>> 13 // 10             # 向下取整
    1
    >>> -13 // 10
    -2                       # -13/10=-1.3    向下取整就是-2

    >>> 3.1 % 2

    1.1
    >>> 6.3 % 2.1
    2.0999999999999996			 # 误差
    >>> 6 % 2
    0
    >>> -17 % 4                  # 余数与%右侧的运算数符号一致
    3
    >>> 17 % -4                  # (17-(-3))能被(-4)整除
    -3
    >>> 5.7 % 4.8
    0.9000000000000004

    >>> 1 < 3 < 5                       #等价于1 < 3 and 3 < 5

    True
    >>> 'Hello' > 'world'               #比较字符串大小，按照ascii码依次比较
    False
    >>> [1, 2, 3] < [1, 2, 4]           #比较列表大小
    True
    >>> 'Hello' > 3                     #字符串和数字不能比较，会报错
    TypeError: unorderable types: str() > int()
    >>> {1, 2, 3} < {1, 2, 3, 4}        #测试是否子集
    True

    >>> 3 in [1, 2, 3]       # 测试3是否存在于列表[1, 2, 3]中

    True
    >>> 5 in range(1, 10, 1) 
    True
        # range()函数简介
        # range()是用来生成指定范围数字的内置函数
        # range()的类型实际上是一个iterable类型，但不是迭代器；它是不可变的序列类型，
        # 可以进行判断元素、查找元素、切片等操作，但不能修改元素；
        >>> x=range(1, 10, 1)
        >>> x[2]		  # 可以多次访问，迭代对象只能访问一次
        3
        >>> x[2] = 7      # 不能对不可变序列赋值
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        TypeError: 'range' object does not support item assignment
    
    >>> 'abc' in 'abcdefg'    #子字符串测试
    True
    >>> for i in (3, 5, 7):   #循环，成员遍历
    print(i, end='\t')        #注意，这里打两个回车才会执行
    3	 5	  7

    >>> 3 is 3

    True
    >>> x = [300, 300, 300]
    >>> x[0] is x[1]        #基于值的内存管理，同一个值在内存中只有一份
    True
    >>> x = [1, 2, 3]
    >>> y = [1, 2, 3]
    >>> x is y              #上面形式创建的x和y不是同一个列表对象
    False
    >>> x==y
    True

    a = 0011 1100

    
    b = 0000 1101
    
    -----------------
    
    a&b = 0000 1100			# 全1为1
    
    a|b = 0011 1101         # 全0为0
    
    a^b = 0011 0001			# 相同为0，不同为1
    
    ~a  = 1100 0011			# 1变0，0变1

    >>> {1, 2, 3} | {3, 4, 5}        	   # 并集，自动去除重复元素，重复的元素只出现一次
    {1, 2, 3, 4, 5}
    >>> {1, 2, 3}.union({3, 4, 5})         # (集合1).union(集合2)，与上面的操作等价
    {1, 2, 3, 4, 5}
    
    >>> {1, 2, 3} & {3, 4, 5}  			   # 差集 找出相同元素
    {3}
    >>> {1, 2, 3}.intersection({3, 4, 5})  # (集合1).intersection(集合2)，与上面的操作等价
    {3}
    
    >>> {1, 2, 3} ^ {3, 4, 5}  			   # 对称差集，排除两者共有的元素，共有元素不出现
    {1, 2, 4, 5}
    >>> {1, 2, 3}.symmetric_difference({3, 4, 5})     #同上
    {1, 2, 4, 5}
    
    >>> {1, 2, 3} - {3, 4, 5}  			   # 前者排除后面集合中包含的元素
    {1, 2}
    >>> {1, 2, 3}.difference({3, 4, 5})    # 同上       
    {1, 2}

    >>> 3>5 and a>3          # 注意，此时并没有定义变量a

    False
    >>> 3>5 or a>3           # 3>5的值为False，所以需要计算后面表达式
    NameError: name 'a' is not defined
    >>> 3<5 or a>3           # 3<5的值为True，不需要计算后面表达式
    True
    >>> 3 and 5              # 最后一个计算的表达式的值作为整个表达式的值
    5
    >>> 3 or 5
    3
    >>> 3 and 5>2
    True
    >>> 3 not in [1, 2, 3]   #逻辑非运算not
    False
    >>> 3 is not 5           #not的计算结果只能是True或False之一
    True

    >>> 'a' in 'b', 'a'

    (False, 'a')             # 'a' in 'b'的值为False，False和'a'组成元组
    >>> 'a' in ('b', 'a')
    True					 # 'a' 是元组('b', 'a')的成员
    >>> x = 3, 5
    >>> x
    (3, 5)					 # 元组声明时若无歧义可以不加括号
    >>> 3 == 3, 5
    (True, 5)				 # 3 == 3 表达式的值为True ，True和5组成元组
    >>> x = 3+5, 7
    >>> x					 # 3+5表达式的值为8，8和7组成元组
    (8, 7)

    >>> a = [1,2,3]

    >>> b = [4,5,6]
    >>> c = a + b
    >>> c
    [1, 2, 3, 4, 5, 6]
    >>> d = list(map(str, c))
    >>> d
    ['1', '2', '3', '4', '5', '6']
    >>> import math
    >>> list(map(math.sin, c))
    [0.8414709848078965, 0.9092974268256817, 0.1411200080598672, -0.7568024953079282, -0.9589242746631385, -0.27941549819892586]
    >>> 'Hello' + ' ' + 'world'
    'Hello world'
    >>> 'welcome ' 
    'welcome welcome welcome '
    >>> ('welcome,'*3).rstrip(',')+'!'   #rstrip([chars])，删除 string 字符串末尾的指定字符（默认为空格）.
    'welcome,welcome,welcome!'

    >>> bin(555)                      # 把数字转换为二进制串
    '0b1000101011'
    >>> oct(555)                      # 转换为八进制串
    '0o1053'
    >>> hex(555)                      # 转换为十六进制串
    '0x22b'

    >>> int(3.5)
    3
    >>> int(-3.5)
    -3
    >>> int('101', 2)             # 二进制, 第二个参数表示源数据的进制，源数据可以带进制标识也可以不带
    5
    >>> int('101', 16)            # 十六进制
    257
    >>> int('x2', 36)             # 36进制，2—36进制都可以转十进制
    1190
    >>> int('\t 8 \n')            # 自动忽略数字两侧的空白字符

    # 用法 ascii(object)
    
    >>> ascii('hello')      # 返回字符串'hello'的可读版本，类似repr()函数
    "'hello'"
    >>> ascii('23')
    "'23'"
    >>> ascii((1,2,3))
    '(1, 2, 3)'
    >>> ascii([1,2,3])
    '[1, 2, 3]'
    >>> ascii({1:2,3:4})
    '{1: 2, 3: 4}'
    >>> ascii(12)
    '12'
    
    >>> ascii('中国')      # 参数不属于ASCII码，会转换成转义字符
    "'\ u4e2d\ u56fd'"
    >>> eval(_)			  # _ 表示最近一个终端输出的结果，结果是什么类型，_ 就是什么类型，不一定是字符串
    '中国'

    >>> import random			# 导入random模块,random库是产生随机数的库
    >>> a = [random.randint(1,100) for i in range(10)]   #列表推导式
    >>> a
    [72, 26, 80, 65, 34, 86, 19, 74, 52, 40]
    """
    a = [random.randint(1,100) for i in range(10)]
    for循环执行10次并运行10次random.randint(1,100)语句，
    产生10个随机数，
    循环每执行一次往列表里添加一个元素
    第一次循环产生的随机数排在列表最前面
    """
    
    >>> print(max(a), min(a), sum(a))
    86 19 548           # 找到列表中的最大值、最小值，并计算列表中元素的和
    >>> x=range(11)		# 返回range类型的对象，保存到x中
    >>> sum(x)			# 计算range类型变量中所有元素的和
    55
    
    >>> sum(a)/len(a)	# len()函数计算对象元素个数
    54.8				# 此写法表示计算a列表中元素的平均值
    
    >>> sum([1,2,3,4],4)			# 计算列表各元素的和，并加上4
    14
    >>> sum([1,2,3,4],start=4)		# 计算列表各元素的和，并加上4，start可省略
    14
    >>> max([1,2,22,111,31])		
    111
    >>> max([1,2,22,111,31],key=str)
    31
    >>> max([1,2,22,111,31],key=lambda x:len(str(x)))
    111
    >>> from random import randint
    >>> x=[[randint(1,50) for i in range(5)] for j in range(30)]
    >>> print(x)
    >>> min(*x,key=sum)
    [21, 5, 33, 14, 13]
    >>> x1=(1,2,3)
    >>> print(*x1)
    1 2 3
    >>> x2=[[1,2,3],[2,3,4],[3,4,5]]
    >>> print(*x2)
    [1, 2, 3] [2, 3, 4] [3, 4, 5]
    
    >>> a={1:2,2:2,3:1,4:'aa'}                  
    >>> max(a)	
    4							#比较字典里面的最大值，会输出最大的键值

    >>> ord('a')                   
    97                             # 返回'a'的Unicode码为97
    >>> chr(ord('A')+1)            # 返回'A'的Unicode码，再加1转化为字符'B'
    'B'                            
    >>> str(1234)                  
    '1234'                         # 把整型数字1234转化成字符串'1234'
    >>> str((1,2,3))               
    '(1, 2, 3)'                    # 元组(1,2,3)转化成字符串
    >>> chr(65)
    'A'
     >>> str(1)
    '1'							   # 把整型数字1转化成字符串'1'
    >>> str([1,2,3])
    '[1, 2, 3]'					   # 列表[1,2,3]转化成字符串
    >>> str({1,2,3})
    '{1, 2, 3}'                    # 集合{1,2,3}转化成字符串