Python3

前言

python3，简称py3k；它是不向下兼容的！他是一个解释性语言，交互式语言，面向对象语言。

查看python版本号

①：命令窗口查看
windows+R调出cmd运行框：输出一下命令：

python -v
或
python --version

python中运行.py的文件

举例：打开hellow.py的文件使用的python的脚本为：
$ python3 hellow.py

Python3的基本语法

标志符

①：第一个字符必须是下划线或者字母
②：标志符的其他部分有字母、数字和下划线组成
③：标志符对大小写敏感

python保留字

保留字即是关键字，不能把它当做任何标志符名称。python提供了一个keyword模板，可以输出当前版本的所有关键字：

>>>import keyword
>>>keyword.kwlist
>

注释

python的单行以#开头表示注释；
多行注释可以使用：
‘’’ ‘’’
‘’ ‘’ ‘’
具体如下图所示：

行与缩进

python最具有特色的就是使用缩进行表示块，不需要使用大括号{}
缩进的行数是可变的，但是同一个代码段块的语句必须包含相同的缩进空格数，实例如下图所示：

''
一个代码块行数要求一致
'''
if True:
    print("True")
else:    
print("False")
"""
若是一个代码块所留空格数不一致，会导致运行错误
"""

分别运行结果如下：

多行语句

'''
一个语句多行的话可以通过反斜杠连接\
'''
if True:
    print\
    ("True")
else:    
    print( 
        "False")
"""
在[],{},或者()中的多行语句，不需要使用反斜杠\
注意()中的“”里面的内容不可以分行
"""

数字Number类型

int（整数）：长整数：区分于python2，它没有long数据类型
bool（布尔）：如true
float(浮点数)：如1.23、3E-2
complex（复数），如1+2j等

字符串string

①：‘和’‘的’‘使用完全相同
②：使用三引号’‘‘或者’’ ‘’ ‘’ 可以指定一个多行的字符串
③：转义符
④：可以使用r让\不发生转义（raw string原始字符串）

'''
转义符的使用
'''
if True:
    print ("this is \n ESC(escape charater（date processing）")
    print (r"this isn't \n ESC(escape charater（date processing）")
else:    
    print( 
        "False")
"""

⑤：字面意思连接字符串

"this""is""string"

自动转化为：

"this is string"

⑥：字符串可以使用+运算符连接在一起，用*运算符重复
⑦：python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
⑧：python中的字符串不能改变
⑨：python中没有单独的字符类型，一个字符就是长度为1的字符串
⑩：字符串截取的语法格式如下：变量[头下标:尾下标:步长]

'''
字符串的使用
'''
str = '123456789'

print(str)
print(str[0:-1])
print(str[1:])
print(str[0])
print(str[5])
print(str[2:5])#这边需要注意下，2表示的是2-1=1.而5就是指的是5；
print(str[1:9:2])
print(str*2)
print(str + '你好')

运行结果如下：

十一、python format格式化函数
格式化字符串的函数str.format()，他增加了字符串格式化功能
基本语法是通过{ }和：来代替以前的%
format函数可以接收限个参数，位置可以不按顺序

空行

①：函数之间或类的方法之间用空行分隔，表示一段新的代码开始
②：类和函数入口之间也用一行空行分隔，以突出函数入口的开始
空行与代码缩进不同，空行并不是python语法的一部分。书法时不插入空行，编译器不会出错，但是空行的作用在于分割两端不同功能或者含义的代码，便于日后代码的维护或重构

等待用户输入

'''
等待用户输入
'''

input("\n\n按下enter键后退出并显示")

这边注意下：这里需要在交互端运行，不能在终端运行，否则看不出变化

在方框处键入你想输入的数值然后按下enter！

同一行显示多条语句

Python中可以使用多个语句构成一行，每个语句之间使用；分隔

import sys;x = 'runoob';sys.stdout.write(x+'\n')

多个语句组成多个代码组

缩进相同的一组语句构成一个代码块，称之为代码组。
相if，while,def和class这样的复合语句，开始以冒号（:）结束，该行之后一行或者多行代码构成代码组。
将首行和后面的代码组称为一个子句（clause）

if expression
	suite
elif expression
	suite
else :
	suite

print输出

①：默认输出是换行的
②：在print（）语句中增加end = ‘’ ‘’，实现不换行
③：print打印的时候双引号和单引号都可以当做定界符使用，且可以嵌套。被嵌套的会被解释为标点符号

import与from…import

①：将整个模块（somemodule）导入，格式为：import somemodule
②：从某个模块中导入某个特定的函数，格式为：from somemodule import somefunction
③：从某个模块中导入多个函数，格式为：
from somemodule import firstfunc，secondfunc，thirdfunc
④：将某个模块的全部函数导入，格式为：
from somemodule import *
⑤：给模块换个名字：import somemodule as
根据①，导入sys模块

#导入sys模块
import sys 
print('-------------Python import mode------------')
print('命令行参数为：')
for i  in sys.argv:
    print(i)
print('\ python 路径为',sys.path)

#导入sys中特定的成员

from sys import argv,path
print('path',path)  
#或者
print('path',sys.path)  

命令行参数

！！！！有点问题，可以先看，后面补充修改
很多程序可以执行一些操作来查看一些基本信息，python可以使用-h查看各参数的帮助信息
python提供了getopt模板来获取命令行参数。getopt模块是专门处理命令行参数的模板，用于获取命令行选项和参数，也就是sys.argv。

args

使用sys.argv[]可以接收脚本的参数，得到一个列表类型，列表第一个元素是脚本名称，通过sys.argv[1:]得到命令行传进来的所有参数

import sys
argv = sys.argv[1:]
#得到命令行所有传进来的参数
print("args==argv==", argv)

import sys

print('参数个数为：',len(sys.argv),'个参数.')
#argv:命令行参数列表

print("参数列表:",str(sys.argv))

print('脚本名：',str(sys.argv[0]))

命令行的选项使得程序的参数更加灵活。支持短选项模式-和长选项模式–。该模式提供了两个方法和一个异常处理来解析命令行参数。

getopt

语法格式如下：
getopt.getopt(args,shortopts,longoptions=[ ])
方法参数说明：
args：要解析的命令行参数列表。直接把sys.arg[1:]切片传进来就可以了,一般为sys.argv[1:]
shortopts：这个参数是个字符串，把需要解析的“短选项”挨着写在一起就可以，这里的短选项指的是‘-’开头的选项，叫短选项是这个选项值只支持单字母，就算你写-test这样子的书写，能被getopt识别的也是-t和est，其中est会被当做-t选项的参数。所以你想支持“-h -i -o”三个短选项，shortopts可以写为“hio”。如果某个短选项想接受参数，比如“-h-i inputfiles -o outputfile”，那就需要在字母后面加“：”冒号，变成“hi:o”
longopts=[]: 这个参数是个列表，因为每个长选项有多个字母，不可能像短选项一样用一个字符串就都表示出来。所谓长选项，就是以 “–” 开头的选项，比如 --usr --ifile --ofile 等，传参的时候写成 [‘–user’, ‘–ifile’, ‘–ofile’]，如果某个选项需要接受参数，则在后面加 “=” 等号，比如 [‘–user’, ‘–ifile=’, ‘–ofile=’]。
返回值，有两个：
opts：是有一个元组列表，列表里是元组（opt, value）的格式。比如上面的 “-h -i inputfile -o outputfile” 那就是 [(‘-h’, ‘’), (‘-i’, ‘inputfile’), (‘-o’, ‘outputfile’)] 这样的返回值。长选项和短选项以及各自的参数都会按先后次序放在这里。用的时候可以以 for opt,val in opts: 这样的方式来遍历。值得注意的是，返回的 opt 里面，‘-’ 和 ‘–’ 都被保留下来了，另外，当用户输入的长选项没有写完的时候，会被自动补全。比如用户输入的是 --u，通过 getopt 会被自动补全成 --user，这个需要注意（除非有两个长选项都有相同的开头，无法确定是哪个）。
args：如果用户输入的信息太多，除了长选项和短选项以及各自选项的参数以外，还有一些其它的未知的参数，则会被放到这里。 看了这些，再去看上面的例子，相信会清楚很多了

#错误代码展示：还未找到原因
import getopt
import sys


argv = sys.argv[1:]
print("args==argv==", argv)
options, args = getopt.getopt(sys.argv[1:], "hd:n:", ["help", "date=", "name="])
#这边的shortopts：“hd:n:”短选项-h -d和-n，其中-d和-n后面接收参数
#这边的longsopts:是参数列表，常选项中有很多字母，不能像短选项中一样用一个字符串表示出来。
#如果某个选项接收参数，则后面加“=”
print("args==getopt==",options, "options=====", args)

这边需要注意下：需要定义带-选项的参数，再定义不带-的参数！

argsparse

argsparse是python的命令解析的标准模式，内置于python。区分于getopt，args兼容性更强，可以接收任意方式的传参，getopt对传入参数进行了分组，argsparse则使传入的参数可读性更高，支持的功能多一些。

help（）函数

①：调用help()函数可以打印输出一个函数的文档字符串

>>>help(max)

#仅仅得到文档的字符串：
print(max.__doc__)
#doc的前后是两个下划线

②：需要善用help帮我们查看关键词的基本语法：

help(print)

显示了作用和各参数的含义

def getPairs(dictas):
    for k,v,in dictas.items():
        print(k,v,sep=':')

getPairs({x:x**3 for x in (1,2,3,4)})
#这里的**表示的是几次方的概念

清除交互式界面命令行

方法一

import os
os.system('cls')

方法二

import subprocess
i = subprocess.call（'clas',shell=True）

浮点数字符串转化为整型的方法

a = 2.1#这是一个浮点数
print(int(a))

b ='2.1'#这是一个字符串
print(int(float(a)))

基本数据类类型

变量的创建

①：变量不需要声明，即是不需要说明数据类型(内存中的对象的类型)
②：每个变量使用前必须赋值（=），这样变量才能被创建
③：python是动态的，变量的类型是由赋予它的值来决定的
④：我们所说的数据类型都不是函数，表示的是一个类，type(int)的输出结果表明int是一个类
⑤：赋值操作本质是创建引用

多个变量创建（赋值）

①：

a = b =c= 1

从后向前赋值，赋予相同的数值
②：同时对多个对象指定变量

a,b,c=1,2,'runboot'

a =b=c=1
print(id(a))
print(id(b))
print(id(c))

实例化对象

这边是区分于赋值的，不带括号的叫做赋值，带括号的叫做实例化。不能直接突然冒出一个变量！必须要先使用 ‘=’ 定义变量

标准数据类型

string、list、tuple都属于sequence

Number（数字）

①：不可变数据,不允许改变，意味着改变数据类型的值，将重新分配内存空间
②：int（唯一一种整数类型：长整型）、float、bool、complex（复数：实部和虚部构成：a+bj或者complex(a,b)）
③：python3中，bool是int的子类，True和False可以和数字相加，True ==1、False ==0可以返回ture，可以通过is判断类型

from operator import truediv


a = issubclass(bool,int)
print("issubclass(bool,int) is",a)
 
print(True == 1 )

print(False == 0)
#bool类型的数据可以与int类型的数据相加减

print(True + 1)

print(False + 1)

print(1)

print(0)

④：可以通过del语句删除单个或者多个对象引用

var = 1

del var

print(var)

⑤：常见的数值运算

print(5+4)

print(5-4)

print(5*4)

#/表示除法，得到一个浮点数
print(5/4)

#//除法，得到不一定时整数类型的数，器其与分子分母的数据类型有一定的关系
print(5//4)

print(5%4)

#乘方
print(5**4)

以上可知
a:/区分于c或者c++，他表示的是除法，得到一个浮点数值
b://才是得到不一定是一个整数，其与分子分母的数据类型有关

#3
print(7//2)
#3.0
print(7.0//2)
#3.0
print(7//2.0)

c:**表示的是乘方
d:混合计算的时候，python会将整数转化为浮点数
e:一个变量可以赋予不同类型的对象
f:复数的两种表达方式a+bj，或者complex(a,b),复数的实部a和虚部b都是浮点型

a = 1 + 5j

b = complex(2,3)
print(a)

print(b)

⑥：常见数据类型转换

int(x):将x转化为一个整数
float(x)：将x转化为一个浮点数
complex(x)：将x转化为一个复数，实数部分为x，虚部部分为y。x,y为数字表达式
complex(x,y):将x,y转化为一个复数

这边存在一个注意事项：就是无法将复数转化为浮点数：

String（字符串）

①：不可变数据
②：Python中的字符串用单引号 ’ 或双引号 " 括起来
③：反斜杠\转义特殊字符
④：截取字符串：变量[头下标,尾下标]

str = 'Runoob'

#输出整个字符串：Runoob
print(str)

#输出第一个字符到倒数第一个字符：Runoo
print(str[0:-1])

#输出第一个字符：R
print(str[0])

#特别需要注意的点：输出倒数第一个字符：b
print(str[-1])

#输出第三个字符到第5个字符：noo
print(str[2:5])

#输出第三个字符到最后：noob
print(str[2:])

#字符串输出两遍：RunoobRunoob
print(str*2)

#连接字符串：Runoobtest
print(str+'test')

这边需要区分的是取某个字符串的数值与取一段字符串的数值的表示方式存在些许差异，截取片段的话，数字是在每个节点的中间，而取值是在每个字节上，具体可以看下图：

⑤：反斜杠\为转义特殊字符，如果不想让转义字符反转，需要在字符串前加上一个r，表示输出原始字符串。

print('abcd\nde')
print(r'abcd\nde')

⑥：\还可以表示上下行的额延续，也可以使用’‘’‘’‘…’‘’‘’'跨越多行（待确认除注释外的跨越多行的实现）
⑦：Python没有单独的字符类型，一个字符表示的是长度为1的字符
⑧：python中的字符串不能被改变，这是区分于c的，不能通过索引某个位置的值进行修改

#错误演示字符串的索引赋值
str = 'Runoob'
str[1]=4
print('str[1]')

List（列表）

①：可变数据，使用频率最高
②：列表可以实现大部分数集合的数据结构的实现，列表中的元素的类型可以不相同，他支持数字，字符串甚至可以包含列表（嵌套）
③：列表是在方括号[ ]之间，用逗号分隔开的元素列表
④：和字符串一致，列表同样可以被索引（从0开始，-1为末尾的开始位置）和截取，列表截取（切片）后返回一个包含所需元素的新列表，所以无论输出是一个还是几个元素，输出的结果是有中括号[ ]的
⑤：列表的语法格式为：变量[头下注:尾下标]
⑥：

list= ['abcd',789,2.23,'dfgrew',70.4]
tinylist = [123,'dewfrer']

#输出完整数列
#['abcd',789,2.23,'dfgrew',70.4]
print(list)

#输出第一个元素值
#abcd
print(list[0])

#输出第二个到第4个元素值
#[789,2.23]
print(list[1:3])

#输出从第三个到最后一个元素值
#[2.23，'dfgrew',70.4]
print(list[2:])

#输出两遍tinylist
#[123,'dewfrer',123,'dewfrer']
print(tinylist*2)

#输出连接列表值
#['abcd',789,2.23,'dfgrew',70.4，123,'dewfrer']
print(list+tinylist)

如上：这边的话，截取和索引的方式一致

⑦：与字符串不一致，列表的元素可以被截取（切片）和索引进行个更改

a = [1,2,3,4,5,6]
a[0] = 9
a[2:5]=13,14,15

#9,2,13,14,15,6
print(a)
a[2:5] = []
#9,2,6
print(a)

⑧：python列表的切片可以接收第三个参数，参数的作用是截取步长。若果第三个参数为复数的话，表示逆向读取

def reverseWords(input):
    #通过空格将字符串分隔符，把每个单词分隔为列表
    inputWords = input.split(" ")
    inputWords = inputWords[-1::-1] 
    #[-1::-1]：第一个参数-1表示最后一个元素，第二个参数为空，表示移位到列表末尾，第三个参数为步长，-1表示逆序
    output = ' '.join(inputWords) 
    return  output

if __name__ == "__main__":
    input = 'I like you'
    rw = reverseWords(input)
    print(rw)

日后需要研究的代码，表述方法可以更改，暂时不急

##日后需要研究的代码
a = [1,2,3,4,5,6]
a[0] = 9
a[-1:-4]=13,14,15

#9,2,13,14,15,6
print(a)

Tuple(元组)

①：不可变数据，即元组中的元素不能修改
②：元组使用的是（），元素之间使用的是逗号隔开，元组中的元素也是可以不同的

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

# 输出完整元组:( 'abcd', 786 , 2.23, 'runoob', 70.2  )
print (tuple)     

# 输出元组的第一个元素:'abcd'
print (tuple[0])          

# 输出从第二个元素开始到第三个元素:786,2.23
print (tuple[1:3])      

 # 输出从第三个元素开始的所有元素: 2.23, 'runoob', 70.2
print (tuple[2:])    

# 输出两次元组:(123, 'runoob'，123, 'runoob' )
print (tinytuple * 2)     

# 连接元组:( 'abcd', 786 , 2.23, 'runoob', 70.2 ， 123, 'runoob')
print (tuple + tinytuple) # 连接元组

实际上可以将字符串看为特殊的元组

tup = (1,2,3,4,5,6)
print(tup[0])
print(tup[1:5])
tup[0]=12

③：本质上函数的返回值只有一个，函数值返回多个数值的时候，是以元组的方式返回的。

def example(a,b):
    return(a,b)
type(example(3,4))

结果是：tuple(原组)
④：python中的函数还可以接收可变长参数，比如以“*”开头的参数名，会将所有的参数收集到元组上：

def example(*a):
    print(a)
    return(a)

print(type(example(3,4,5,6,7,8)))

⑤：相对于list，tuple是不可变的，这使得它可以作为dict的key，或者扔进set里面，而list是不行的
⑥：list放弃了对元素的增删（内存结构上精简）换取了性能上的提升：创建tuple比list要快，存储空间比list小。
⑦：虽然tuple的元素不可改变，但它可以包含可变的对象，如list列表，构造中包含0和1个元素比较特殊，虽有有一些额外的语法规则：

tup1 = ()  #空元组
tup2 = (20,),#一个元素，需要在元素后面添加逗号
print(type(tup2))

temp = (20)
print(type(temp))
 
print(8*8)

#元组中只有一个元素的时候，括号和括号中的','特别重要
print(8*(8,))

print(8*8,)

⑧：更新删除元组
直接在同一个元组上更新是不可行的，但是可以通过拷贝现有的元组片段构造一个新的元组的方式解决。
通过分片的方式拆分两部分，然后再使用（+进行连接）形成一个新的元组

temp = ("龙猫","泰迪","叮当猫")
#"龙猫","泰迪","小猪佩奇","叮当猫"
temp = temp[:2] + ("小猪佩奇",)+temp[2:]
print(temp)

#"龙猫","泰迪","叮当猫"
temp = temp[:2] + temp[3:]
print(temp)

#in和not in可以直接使用在元组上，跟列表是一致的
a ="泰迪"
c = ('泰迪', '小猪佩奇')
b = a in temp
d =c in temp
f =c not in temp
print(b)
print(d)
print(f)

#使用del删除元组的时候，
#python的回收机制会在这个元组不再被使用的时候自动删除
del temp
print(temp)

Set（集合）

①：可变数据
②：集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的实物或者对象称为元素或者成员。
③：基本功能是进行成员关系测试和删除重复元素
④：使用{ }或者set（）函数创建集合
⑤：创建一个空集合必须是set()，而不是{ }，因为{ }是用于创建空字典

param = { value1,value2}
#或者
set(value)

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu', 'Taobao'}

#{'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')


# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

#{a , b , r , c , d}
print(a)

#{a,l,c,z,m}
print(b)

#{b,r,d}
print(a - b)     # a 和 b 的差集


#{a , b , r , c , d , l , z , m}
print(a | b)     # a 和 b 的并集


#{a , c}
print(a & b)     # a 和 b 的交集

#{b,r,d,l,z,m}
print(a ^ b)     # a 和 b 中不同时存在的元素

这边需要注意 “ ^ ” 表示不同时存在
⑥：集合是无序的，所以是支持索引的，且是无重复的元素的序列，会自动去除重复元素。

Dictionary（字典）

①：可变数据
②：字典（dictionary）是python内置的数据类型
③：列表是有序的对象合集，字典是无序的对象集合
④：字典与列表的区别在于字典当中的元素是通过键来存取的，而不是通过偏移存取的。
⑤：字典是一种映射类型，字典用{ }标识，它是一个无序的键（key）：值(value)的集合
⑥：键（key）必须使用不可变类型
⑦：在同一个字典中，键（key）必须是唯一的

tdict = { }
tdict['one'] = "1-百度教程"
tdict[2]     = "2-百度工具"

tinydict = {'name':'baidu','code':1,'site':'wwww.baidu.com'}

print(tdict['one'])
print(tdict[2])
print(tinydict)
print(tinydict.keys)
print(tinydict.values)

构造函数dict()可以直接从键值对序列中构建字典：

dict([('weq',1),('qweq',2)])

⑧：python中的字典使用了称为散列表（hashtable）的算法
其特点是：不管字典中有多少项，in操作符花费的时间都差不多
如果把一个字典对象作为for的迭代对象，那么这个操作会遍历字典中的键

#a是一个字典对象
def example(a):
    for c in a:
     print(c)

#可知：调用函数的时候，函数将d所有的键打印出来了
#也就是遍历了d的键而不是所有的值
example({1:'a',2:'b',3:'c'})

⑨：在⑧中的修改成输出完整的情况：

def example(a):
    for c in a:
     print(c,':',a[c])

example({1:'a',2:'b',3:'c'})

或者：使用items( )函数完成键值对的输出：

def example(a):
    for c ,v in a.items():
     print(c,':',v)

example({1:'a',2:'b',3:'c'})

⑩：创建字典的多种表述方式

#元素为元组的列表
dict_1 = dict([('a',1),('b',2),('c',3)])
print(dict_1)
#元素为元组的集合
dict_2 = dict({('a',1),('b',2),('c',3)})
print(dict_2)
#元素为列表的列表
dict_3 = dict([['a',1],['b',2],['c',3]])
print(dict_3)
#元素为元组的元组
dict_4 = dict((('a',1),('b',2),('c',3)))
print(dict_4)

⑨：创建一个空集合必须是set()，而不是{ }，因为{ }是用于创建空字典

o = {1,2,3}
print(type(o))
o = {}
print(type(o))

判断数据类型

①、可以通过内置的type（）函数查询变量所指的对象类型，用于求解未知数据类型，不管其父类类型

a,b,c,d=1,2,'runboot',True
print(type(a),type(b),type(c),type(d))

②：通过isinstance判断比较确定数据类型，判断A类继承于B类：

class A:
    pass

class B(A):
    pass

a = isinstance(A(),A)
b = type(A())==A
print(a)
print(b)
#实例化对象和类的地址不一致
print(id(A))
print(id(A()))
#type()不会认为子类是一种父类
#isinstance()会认为子类是一种父类类型
c  = isinstance(B(),A)
d = type(B()) == A
print(c)
print(d)

强调点

①：列表[]，集合{}，元组（）有所不同记得区分：

clist = ['a', 'b','c','a']
print(clist)
ctuple = ('a', 'b','c','a')
print(ctuple)
cset = {'a', 'b','c','a'}
print(cset)

这边还有一个注意点：就是集合的输出是无序的
②：赋值操作本质是创建引用，创建了变量指向对象内存的指针，变量是变量，对象是对象，当某个对象赋予某个变量时，，可以认为创建了变量对该对象的引用
③：变量没有数据类型之说，只有对象有，即变量不是直接代表对象或者对象的内存空间，对象内部空间记录了当前引用次数和数据类型两个信息
当引用次数为0的时候，python会自动收回对象内存空间
④：#python为了提高代码执行速度和内存分配效率，会对常见的对象，创建好，并长驻内存

#赋值操作本质是创建引用，创建了变量指向对象内存的指针
#变量是变量，对象是对象，当某个对象赋予某个变量时，
#可以认为创建了变量对该对象的引用
#变量没有数据类型之说，只有对象有，
# 即变量不是直接代表对象或者对象的内存空间
#对象内部空间记录了当前引用次数和数据类型两个信息
#当引用次数为0的时候，python会自动收回对象内存空间
a =10 
a = '1234'
a = [1,2,4]
del a
#python为了提高代码执行速度和内存分配效率，会对常见的对象，创建好，并长驻内存

#无论多少遍，返回值均不变
print(id(4))
print(id(5))

数据类型转换

隐式数据类型转换

自动转换，不需要干预，python会将较小的数据类型转化为较大的数据类型，避免数据丢失！

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo

print("datatype of num_int:",type(num_int))
print("datatype of num_flo:",type(num_flo))

print("Value of num_new:",num_new)
print("datatype of num_new:",type(num_new))

显式数据类型转换

我们使用int( ),float( ),str( )等预定义函数来执行显示类型转换

Python推导式

列表推导式

[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
或者
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

out_exp_res：列表生成元素表达式，可以是有返回值的函数，这里实验可知他必须是out_exp 的函数或者out_exp本身
for out_exp in input_list：迭代input_list将out_exp传入out_exp_res表达式中
if condition：条件语句，可以过滤列表中不符合条件的值

#作用：过滤掉长度小于或等于3的字符串列表，并将剩下的转化为大写字母
names = ['Bob','Tom','alice','Jerry','Wendy']
#这里的upper()是将字符串变为大写的函数
new_names = [name.upper()for name in names if len(name)>3] 
print(new_names)

字典推导式

字典推导的基本格式：

{key_expr:value_expr for value in collection}
#或
{key_expr:value_expr for value in collection if condition}

举例：

#使用字符串及其长度创建字典
listdemo = ['baidu','sougou','tengxun']
newdict = {key:len(key) for key in listdemo}
print(newdict)

#提供三个数字，以三个数字为键，三个数字的平方值来创建字典
dict = {x:x**2 for x in (2,4,6)}
print (dict)
print (type(dict))

集合推导式

{expression for item in Sequence}
{expression for item in Sequence if conditional}

setnew = {i**2 for i in (1,2,3)}
print(setnew)

a = {x for x in 'abcdefghi' if x not in 'abc'}
print(a)
print(type())

元组推导式（生成器表达式）

元组推导式可以利用range区间，元组，列表，字典和集合等数据类型，快速生成一个满足指定需求的元组

expression for item inSequence
或者
expression for item in sequence if conditional

元组推导式与列表推导式的用法完全相同，知识元组推导式使用的是()圆括号将各部分括起来，而列表推导式用的是中括号[]，另外，元组推导式生成的结果是一个生成器对象。

a = (x for x in range(1,10))
print(a)
#元组推导器的返回结果是一个生成器对象
print(type(a))

#使用tuple()函数，可以直接将生成器对象转化为元组
print(tuple(a))

Python3解释器

交互式编程

通过Windows建和R打开运行符，输入cmd，进入命令符界面：

在交互式环境中，编译器会有一个小整数池的概念，会将(-5,256)（64位系统）间的数预先创建好，当指向同一个内容（数值）的两个变量超过这个范围的时候，两个地址是不一样的，如下所示：

脚本式编程

脚本编译器中同一个内容或者数值所指的不同的变量，id地址是相同的。

Python3注释

①：单行#
②：多行：三个单引号‘’‘或者三个多引号’’ ‘’ ‘’ ‘’ ‘’ ‘’

''' '''
'' '' ''      '' '' ''

③：打印输出函数的注释
函数中由语句的时候，除了将注释放在第一行，否则是无法输出的。

def c():
    """
    EWRDFWE
    """
    pass
print(c.__doc__)

Python3运算符

运算符主要是由操作数和运算符构成

python的算术运算符

a = 21
b = 10
c = 0

#31 
c = a + b
print ("1 - c 的值为：", c)

#11 
c = a - b
print ("2 - c 的值为：", c)
 
#11 210
c = a * b
print ("3 - c 的值为：", c)
 
 #2.1
c = a / b
print ("4 - c 的值为：", c)
 
 #1 
c = a % b
print ("5 - c 的值为：", c)
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
#8 幂：返回a的b次幂的值
print ("6 - c 的值为：", c)
 
a = 10
b = 5
c = a//b 
#2,//取整数，向下去接近商的整数
print ("7 - c 的值为：", c)

python的比较运算符

a = 21
b = 10
c = 0
 
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")
 
if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")
 
if ( a < b ):
   print ("3 - a 小于 b")
else:
   print ("3 - a 大于等于 b")
 
if ( a > b ):
   print ("4 - a 大于 b")
else:
   print ("4 - a 小于等于 b")
 
# 修改变量 a 和 b 的值
a = 5
b = 20
if ( a <= b ):
   print ("5 - a 小于等于 b")
else:
   print ("5 - a 大于  b")
 
if ( b >= a ):
   print ("6 - b 大于等于 a")
else:
   print ("6 - b 小于 a")

python的赋值运算符

Python中数字的的表达方式为：
2进制以0b（bin文件）开头，0b11表示数字3
8进制是以0o开头，0o11表示数字9
16进制是以0x表示，例如0x11表示的是十进制17

a = 0b00011110
print(a)
#输出二进制的值
print(bin(a))
#输出十进制的值
print(oct(a))
#输出十六进制的值
print(hex(a))

除了常见的之外：补充重要的：
:=海象运算符，可在表达式内部为变量赋值。

a = 'sdsfjksfdsfdeds'
if (n :=len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

python的位运算符

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
#按位与 
c = a & b        # 12 = 0000 1100
print ("1 - c 的值为：", c)
 
#按位或 
c = a | b        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
 
#按位异或  
c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值为：", c)

#按位取反  
c = ~a           # -61 = 1100 0011
print ("4 - c 的值为：", c)

#左移两位 
c = a << 2       # 240 = 1111 0000
print ("5 - c 的值为：", c)
 
#右移两位  
c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值为：", c)

python的逻辑运算符

①：常见的逻辑运算符

a = 10
b = 20
c = -10
d = 0
#and从左到右计算表达式，若所有值为真，则返回最后一个值，若存在假，返回第一个假值
#or 也是从左往右计算表达式，返回第一个为真的值
#其中数字0位假，其他为真的值，包括负数
#字符''''是假，其他都是真
#and返回的是最后一个真值
#20
#and返回的是最后一个真值
print(a and b)
#10
# or 返回的是第一个真值
print(a or  b)
#20
print(c and b)
#-10
print(c or  b)
#20
print(b or  c)
#20
print(b or  d)
#-10
print(d or  c)
#0
print(d and c)
#0
print(c and d)
#20
print(c and b)

②：逻辑运算符额优先级：
not > and > or

#先是not false为true，
# 接着1 and 0 的值为0，
# 最后是or，结果为真->true
print(1 and 0 or not False )

#先是not false为true，
# 接着1 and 0 的值为0，
# 最后是or，结果为真->true
print(not False or 1 and 0 )

#先是not true为false，
# 接着false and 0 的值为1，
# 最后是or，结果为真->1
print( 1 or not True and 0)  

python的成员运算符

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

python的身份运算符

作用：比较两个对象的存储单元

注意点：
is和 == 的区别：
is是用于判断两个变量引用对象是否为同一个，通过id来判断的；当两个基本类型数据（或元组）内容相同时，id会相同，但不代表着a随着b的改变而改变；‘‘= =’’用于判断引用变量的值是否相等，是通过调用函数_eq_()来判断的。

a = [1, 2, 3]
b = a
print (a)
print (b)
print(id(a))
print(id(b))
print(b is a) 
print(b == a)
b = a[:]
print(a)
print(b)
print(id(a))
print(id(b))
#is用于判断两个变量引用对象是否同一个，==用于判断引用变量的值是否相等
print(b is a)
print(b == a)

函数

数学函数

随机数函数

除了以上列举之外，常见的还有randint和sample类型：

#random.randint(x,y)
#随机生成一个整数int类型，可以指定整数的范围
import random
random.randint(1000,9999)

#random.sample(sequence,length)
#可以从指定的序列中，随机的截取指定长度的片段
#不修改原序列
import random
while 1:
    a = random.sample('10101010010001111001001001',13)
    print(a)

三角函数

数学常量

round函数（坑，放弃补充，用到再说）

round(a,x):round函数用来对某个数值进行四舍五入，其中a为对象，x为“4舍6入5看齐，奇进偶不进”’即是小数，其为0的时候，只保留整数。

tax = 12.5 / 100
price = 100.51
#保留整数位，根据小数位决定是否进位
print(round(price))
#保留整数位，将小数第一位以0补全
print(round(price,0))
#保留整数位，将小数第一位以0补全
print(round(price,1))
print(round(price,2))
print(round(price,3))

enumerate()函数

作用：进行进行遍历

sequence = [12, 34, 34, 23, 45, 76, 89]
for  j in enumerate(sequence):
    print(j)

range()函数

①：遍历数字序列，可以使用内置的range()函数：

#0 1 2 3 4 
for i  in range(5):
    print(i)

②：range指定区间的值：
range(a,b)：包含a，但是不包含b

#5,6,7,8
for i  in range(5,9):
    print(i)

③：也可以制定数字开始，并且制定增量（步长）

for i  in range(1,12,2):
    print(i)

④：通过range()和len()函数遍历一个序列的索引

注意事项

_的使用

首先_是什么：他代表上次的输出结果
其次：其是可以赋值的，其一旦赋值之后，其值固定，除非使用del_才能解除

tax = 12.5 / 100
price = 100.51
#这里的_代表了上次输出的结果，我们也是可以对其赋值的
print(_+200)
#保留整数位，将小数第一位以0补全
_=300
print(_)
#但一旦赋值之后，_值变成定值，除非你是用del_
a=100
print(_)

pass的使用

pass只是为了防止语法错误。

a = 0
if a>1:
#pass是一条空语句，
#在代码中或定义函数的时候，如果没有内容，则不先做任何处理，直接跳过的话，可以使用pass
    pass
else:
    print('else的实现')
print(a,'<1')

__init__的使用

创建类时，可以手动添加一个__init__()方法，该方法是一个特殊的类实例的方法，称为构造方案（或构造函数）。
构造方法用于创建对象使用，每当创建一个类的实例对象的时候，python解释器会自动调用它。python类中，手动添加构造方法的语法的格式如下：

def __init__(self,...)
  代码块

两个下划线开头的函数是声明该属性是私有，不能在类的外部被使用或者访问。而__init__函数（方法）支持带参数类的初始化，也可声明该类的属性（类中的变量）。
__init__函数（方法）的第一个参数必须为self，后续参数为自己定义。

class AssignValue(object): 
    def __init__(self,value):
        self.value = value
my_value = AssignValue(6)
print('value 为：{0.value} '.format(my_value))#'0'是可选的