Python重启之Python基础

开发语言

　　高级语言：Python、JAVA、PHP、C#、GO、ruby、C++（生成字节码）

　　低级语言：C、汇编（生成机器码）

　　语言之间的对比

　　　　PHP类：适用于写网页，局限性

　　　　Python、Java：既可以写网页，也可以写后台功能（两者相比，前者执行效率低，开发效率高；后者执行效率高，开发效率低）

Python种类

　　JPython

　　IronPython

　　CPython

　　JavaScriptPython

　　RubyPython

　　pypy　　这是用CPython开发的Python（当开发完成，会自动执行一遍形成机器码，保存下来，以便以后直接使用机器码）执行速度比CPython快

　　……

Python基础

　　Linux系统中的Python文件内部开头必须要有以下代码—↓（第二行如果是Python3以上版本可不加）

#!/usr/bin/env python

# -*- coding:utf8 -*-

　　Python软件就是Python解释器（内存管理）

　　Python的后缀名为.py

　　单行注释用#　　多行注释用开头结尾各三个单引号或双引号。

　　基本数据类型（字符串、整型、布尔、列表、字典、元组、集合）str、int、bool、list、dict、tuple、set　　　　——通常不同数据类型之间转换可以直接用目标类名转换（前提是源数据的元素都是同一种类型），但有些数据类型含有多种数据类型的元素，则自己写for循环转换

　　　　所有数据类型（除了整型和布尔）都能用的方法：

　　　　　　索引（索引中是从0开始，即第一个元素的索引值为0，且最后一个元素的索引值为-1）　　　　——注意字典的索引是key，集合不支持索引

　　　　　　　　a[n]　　返回字符串中的第n-1个字符，可赋值　　　　　　

　　　　　　切片　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——字典没有切片，集合不支持切片

　　　　　　　　a[n:m]　　返回字符串a中[n,m)的字符串，可赋值　　　　——注意区间，左包含，右不包含

　　　　　　len(a)　　返回字符串a的元素总数，可赋值

　　　　　　for i in a　　循环遍历a　　　　——所有数据类型（除了整型、布尔值）都是可迭代对象　　　　　　——字典默认循环所有key

　　　　字符串（str）：由引号开头并结尾，元素之间无分隔符的叫字符串。例如' '、" "、''' '''、""" """（只有这四种组合）。有加法和乘法功能。

　　　　　　方法：

　　　　　　　　a.join(n)　　返回字符串a的每个元素间加入n的字符串，可赋值　　　　　　——也就是每个元素按指定的分隔符进行拼接（n如果是其他数据类型并内部所有数据类型都是字符串，则可用空字符串或下划线.join(n)来完成其他数据类型转换成字符串类型）

　　　　　　　　a.split(n,m)　　把字符串a以n为分割线进行最大m次的分割，返回的列表不包含n，可赋值　　　　　　——返回的是列表

　　　　　　　　a.find(n,m,z)　　返回n在a的[m,z)的范围中第一次出现的索引值，若没找到则返回-1，可赋值

　　　　　　　　a.strip(n)　　左右两边同时循环每个元素，去掉与n中元素相同的，遇到没有与n中元素相匹配停止，未指定n时去掉空格和回车和换行，可赋值　　　　——按最长公共子序列

　　　　　　　　a.upper()　　把字符串a中的全部英文改成大写，可赋值

　　　　　　　　a.lower()　　把字符串a中的全部英文改成小写，可赋值

　　　　　　　　a.replace(n,m,x)　　把字符串a中的n替换成m，最多替换X次（默认替换所有）。可赋值

　　　　　　　　a.startswith(b)　　返回字符串a是否以b开头，可赋值

　　　　　　　　a.endswith(b)　　返回字符串a是否以b结尾，可赋值

　　　　　　　　a.format(n=b)　　在a中寻找{n}并替换成b，可赋值　　　　　　——这方法其实叫格式化　　　　a.format(**{这是一个字典}) 可以传一个字典进去，若是列表则一个*

　　　　　　　　　　a里可以用{5}这种索引值，a.format(n)，然后对应n[5]映射进a里

　　　　　　　　a.format_map({n:m})　　在a中寻找{n}并替换成b，{n:m}其实就是一个字典，可赋值　　　　　　——格式化

　　　　　　　　'&s' %n　　（n为单个字符串。s代表传输字符串）

　　　　　　　　‘%s,%d’ %(a,b)　　（a为字符串，b为整型，d代表传输整型 ）

　　　　　　　　%.2f　　代表传输浮点数，并四舍五入保留小数点后两位（.2可省略，默认保留6位）

　　　　　　　　'%(key)' %{key:value}

　　　　　　　　例如

　　　　　　　　n = eval(input("请输入正整数:"))
　　　　　　　　print("{:->20,}".format(n))　　

　　　　　　　　a.splitlines(n)　　把字符串a以换行符进行分割，如果n=True则返回保留换行符，否则不保留，可赋值

　　　　　　　　a.lstrip(n)　　去掉左边的n，未指定n时去掉空格和回车和换行，可赋值

　　　　　　　　a.rstrip(n)　　去掉右边的n，未指定n时去掉空格和回车和换行，可赋值

　　　　　　　　a.casefold()　　把字符串a中的全部字符（不一定是英文）改成小写，可赋值

　　　　　　　　a.swapcase()　　把字符串a中大写转换小写，小写转大写，可赋值

　　　　　　　　a.capitalize()　　返回首字母大写的字符串a。可赋值

　　　　　　　　a.center(n,'+')　　在字符串a前后各加1/2n个‘+’，可赋值

　　　　　　　　a.ljust(n,'+')　　在字符串a左边加n个‘+’，可赋值

　　　　　　　　a.rjust(n,'+')　　在字符串a右边加n个‘+’，可赋值

　　　　　　　　a.count(n,m,z)　　返回在字符串a的[m,z)范围中，n出现的次数，可赋值

　　　　　　　　a.index(n)　　返回n在a的[m,z)的范围中第一次出现的偏移值,若没找到则报错，可赋值

　　　　　　　　a.isalnum()　　返回字符串a是否是全为字母或数字，可赋值

　　　　　　　　a.expandtabs(n)　　把字符串a从前到后每n个为一组进行分割，分割过程中遇到\t（水平制表符）则变成空格与前面未分组的元素凑成一组，空格个数为(n-前面元素个数)，若\t前面没有未分组的元素，则自身变成n个空格。最后返回合成的字符串。可赋值　　　　　　　　——这个可以用来制作表格，例如a = 'u\te\tp\nuser1\tuser1@qq.com\tuser1p\nuser2\tuser2@qq.com\tuser2p\n'

　　　　　　　　a.isalpha()　　返回字符串a是否全是字母，可赋值

　　　　　　　　a.isdecimal()　　返回字符串a是否全是数字，可赋值

　　　　　　　　a.isdigit()　　返回字符串a是否全是数字或全是特殊的数字（例如②），可赋值

　　　　　　　　a.isnumeric()　　返回字符串a是否全是数字或全是特殊的数字（例如②、二），比以上两种支持的种类要多，可赋值

　　　　　　　　a.isidentifier()　　返回字符串a是否由字母，数字，下划线组成但数字不能开头，可赋值　　　　——字母，数字和下划线统称为标识符

　　　　　　　　a.islower()　　返回字符串a是否全是小写，可赋值

　　　　　　　　a.isupper()　　返回字符串a是否全是大写，可赋值

　　　　　　　　a.isprintable()　　返回字符串a是否不包含转义字符（例如换行符（\n）），可赋值

　　　　　　　　a.isspace()　　返回字符串a是否全是空格，可赋值

　　　　　　　　a.istitle()　　返回字符串a是否是标题（是否是每一个字段都首字母大写），可赋值

　　　　　　　　a.title()　　返回字符串a的标题形式，可赋值

　　　　　　　　a.partition(n)　　把字符串a从左到右，以第一个n为分割线分割成三个部分，可赋值　　　　——返回的值为元组

　　　　　　　　a.rpartition(n)　　把字符串a从右到左，以第一个n为分割线分割成三个部分，可赋值

　　　　　　　　正则表达式　　可选择是否包含分割的元素

　　　　　　　　str.maketrans(n,m)　　相当于创建一个字典，n的元素和m一一对应（n[0]:m[0]），n和m的元素个数必须一致，可赋值

　　　　　　　　a.translate(m)　　m为一个字典，把字符串a中与m中的key相同的元素  替换成  m中对应key中的value，可赋值

　　　　　　　　encode

　　　　　　　　decode

　　　　整型（int）：也就是数字。

　　　　　　运算符

　　　　　　　　*表示乘法，**表示幂，%表示取余，//表示floor除法（也就是不大于的最大整数）、!=表示不等于、==表示等于、=表示赋值

　　　　　　　　结果是值：算数运算、赋值运算

　　　　　　　　结果是布尔值：比较运算、逻辑运算、成员运算，可赋值

　　　　　　方法：

　　　　　　　　a.bit_length()　　把a以二进制的形式，并返回其长度

　　　　布尔值（bool）：True（真）、False（假）

　　　　列表（list）：开头结尾用中括号括起来，元素之间用逗号分隔（每个元素是一个整体）的叫列表。（列表的元素可以是任何数据类型）　　　　　　——有序、元素可变

　　　　　　方法：

　　　　　　　　a.append(n)　　给列表a追加n元素（把n看成一个整体加进列表a），不可赋值

　　　　　　　　a.extend(n)　　循环n中的元素，依次加进列表a中，不可赋值

　　　　　　　　a.insert(n,m)　　在指定索引值为n的位置，加入m，不可赋值

　　　　　　　　range(n,m,x)　　创建一个以[n,m)范围、步长为x的连续整数为(m-n)个元素的列表。可赋值。（若不指定m,x，则默认[0,n)）　　　　　　——后面的数减去前面的数为步长

　　　　　　　　a[n] = 1　　把列表a中第n+1个元素修改成1　　——也可以用切片方式修改多个元素，但元素个数必须一样

　　　　　　　　del a[n]　　删除列表a中第n+1个元素　　——支持切片删除

　　　　　　　　a.pop(index=none)　　指定索引值对应的元素，默认删除最后一个元素，可赋值

　　　　　　　　a.remove(n)　　删除n元素，从左到右删掉第一次出现的n元素

　　　　　　　　a.clear()　　给列表a清空，不可赋值

　　　　　　　　a.copy()　　拷贝列表a，可赋值

　　　　　　　　a.count(n)　　计算n在列表a中出现的次数，可赋值

　　　　　　　　a.index(n,x=none,y=none)　　返回n元素在列表a中[x,y)范围内第一次出现的索引值，可赋值

　　　　　　　　a.reverse()　　翻转列表a，不可赋值

　　　　　　　　a.sort(reverse = False)　　默认从小到大排序

　　　　　　　　a.map

　　　　　　　　a.key

　　　　　　　　a.sorted

　　　　元组（tuple）：开头结尾用小括号括起来，元素之间用逗号分隔（每个元素是一个整体）的叫元组。（元组的元素可以是任何数据类型）　　　　——有序，元素不可变

　　　　　　a.count(n)　　计算n在元组a中出现的次数，可赋值

　　　　　　a.index(n,x=none,y=none)　　返回n元素在元组a中[x,y)范围内第一次出现的索引值，可赋值

　　　　字典（dict）：开头结尾用大括号括起来，内部元素都是单位名为键值对，每一个键值对有一个键（key）和一个值（value），key与value用冒号连接，每一个键值对以逗号连接，字典无序。（除了列表、字典和布尔值不能作为key，不能哈希，value所有数据类型都可以）　　　　——key作为索引，一个字典里的key不能重复

　　　　　　字典的查询速度比列表快，但占空间比列表大。

　　　　　　a.keys()　　返回所有key，可赋值

　　　　　　a.value()　　返回所有value，可赋值

　　　　　　a.items()　　返回所有key和所有value，可赋值　　　　——for k,v in a.items():

　　　　　　a.update(n)　　把字典a以字典n更新，若有相同的key则value更新成n中对应key的对应value，没有的键值对则为a增加，可赋值

　　　　　　a.get(k,d=none)　　返回字典a以k为key对应的value，若key不存在，返回d，可赋值

　　　　　　a.clear()　　清空字典a，可赋值

　　　　　　a.copy()　　浅拷贝字典a，可赋值

　　　　　　a.fromkeys(n,m)　　返回以n为key，以m为value的字典，可赋值

　　　　　　a.pop(k,d=none)　　删除字典a中以k为key的键值对，若key不存在，返回d，可赋值

　　　　　　a.popitem()　　随机删除字典a的一个键值对，可赋值

　　　　　　a.setdefault(n,m)　　在字典a里寻找key为n的键值对，若不存在，则给字典a增加一个以n为key，以m为value的键值对。无论存不存在都返回m，可赋值

　　　　集合（set）：开头结尾由大括号括起来的称为集合。——无序、元素可变且元素没有相同（也就是说可以去重）的　　　　——可哈希

　　　　　　有不可变集合　　frozenset()

　　　　　　a.add(n)　　给集合a添加n元素，可赋值

　　　　　　a.clear()　　清空集合a，可赋值

　　　　　　a.copy()　　浅拷贝集合a，可赋值

　　　　　　a.pop()　　随机删除集合a的一个元素，可赋值

　　　　　　a.remove(n)　　删除集合a中的n元素，若元素n不存在则报错，可赋值

　　　　　　a.discard(n)　　删除集合a中的n元素，若元素n不存在不会报错，可赋值

　　　　　　a.intersection(n)　　返回集合a与集合n的交集，可赋值　　　　——跟and运算一样，'&'

　　　　　　a.union(n)　　返回集合a与集合n的并集，可赋值　　　　——跟or运算一样，'|'

　　　　　　a.symmetric_difference(n)　　返回集合a与集合n的交差补集，可赋值　　　　——跟逻辑异或运算一样，'^'

　　　　　　a.difference(n)　　返回集合a与集合n的差集（即a-n，不包含集合n中的元素），可赋值

　　　　　　a.difference_update(n)　　集合a与集合n的差集更新给集合a（即a -= n），不可赋值

　　　　　　a.isdisjoint(n)　　若没有交集就返回True，可赋值

　　　　　　a.issubset(n)　　判断集合a是否是集合n的子集，可赋值

　　　　　　a.issuperset(n)　　判断集合a是否是集合n的父集，可赋值

　　　　　　a.update(n)　　相当于把n（可迭代数据类型）循环更新（相当于赋值）给a，不可赋值

　　变量由变量名和数值组成。

　　变量名只能由字母、数字、下划线组成，但开头不能为数字，变量名也不能是关键字、最好也不要跟Python内置的东西（内置方法或内置的类）重复。

　　关键字有：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。

　　Python用缩进表示代码块，同一层代码块，缩进也要相同

　　条件语句（if）

'''
if 条件:
    代码块
elif 条件:
    代码块
...
else：
　　代码块
'''

　　循环【while（无限循环）、for（遍历循环）】

（continue、break支持所有循环）
continue #终止当前循环，并开始下一次循环
break #终止所有循环
'''
while 条件:    
    代码块

'''
'''
for 新变量名 in 遍历对象:
　　代码块
'''

 

　　and　　逻辑与（&）　　同一取一

　　or　　逻辑或（|）　　有一取一

　　not　　逻辑非（!）　　相反

　　　　多个and与or连用（最好用括号），按照从左到右顺序进行运算，如果第一个运算后得出False，然后在看后面的运算符是and，那么总体都为False。也就是说，and：遇到False就停止运算，or：遇到True就停止运算

　　input　　a = input('请输入')　　获取用户输入的数据，并以字符串的形式赋值给a

　　print　　print('hello world')　　打印输出'hello world'　　多个数据间分隔符print(a,b,sep='+')以+分割a和b

　　pass　　代指空代码，无意义，只是用于表示代码块。　

　　in　　相当于∈（属于）　　——可迭代对象才可使用此方法

　　type(a)　　返回a的数据类型

　　int(a,base=n)　　n进制的a转换成整型的十进制，可赋值

　　id(n)　　返回n的内存地址，可赋值

　　

　　函数：def为关键字 　　　——函数就是相当于一个变量　　　　　　　　　　在运行整个程序时，每次遇到函数，只会记住函数名，函数的代码块直接保存（不运行，只有在调用函数名时，才会运行）

　　　　没有返回值的函数称为过程　　　　——其实没有返回值，也会返回一个None

　　　　返回值个数=0，返回None

　　　　返回值个数=1，返回object（对象）

　　　　返回值个数>1，返回tuple（元组）

def n(m):        #n为函数名，m为形参（可以是多个形参，可选）
    '''注释'''
    '''代码块'''
    return x    #返回x，return可选，一个函数可有多个return，函数运行时遇到一个return就结束
n(b)　　　　#调用函数n，b为实参（b的个数=m的个数）

　　　　好处

　　　　　　1、减少代码重复

　　　　　　2、保持一致性、易维护

　　　　　　3、可扩展性

　　　　形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放，因此形参只在函数内部有效。

　　　　实参可以是常量，变量，表达式，函数等

　　　　多个形参和实参时，可用位置进行传值，即形参和实参一一对应；也可关键字进行传值，即在调用时n(形参=实参)。若位置和关键字同时使用，位置参数必须在关键字参数左边，否则报错。

　　　　默认参数，即在形参处直接赋值。

　　　　可变长参数*为列表，**为字典　　　　若形参有可变长参数如（m,*args），则实参可传入多个值，先根据位置参数赋值给m，再把剩下的整体变为元组赋值给args，实参调用时也可传入列表，在实参列表前加*表示遍历列表的元素，依次添加到元组args。*args，实参不能传入键值对的形式，形参（m,**kwargs）则可以；**kwargs对应的实参必须是键值对的形式。当*args和**kwargs同时用时，*args在**kwargs的左边，即形参正确写法（m,*args,**kwargs）（这时能接受任意长度的参数）。

　　　　全局变量与局部变量：在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。全局变量的作用域是整个程序，局部变量的作用域是定义该变量的子程序。当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用，在其他地方全局变量起作用。

　　　　　　在子程序内调用或修改全局变量，先声明　　global 变量名　　。声明后此子程序的对应变量都是全局变量；只是调用全局变量，则直接不声明同名的局部变量，即可直接调用

　　　　　　全局变量用大写，局部变量用小写。