静水深流

python笔记

发表于 2020-02-28 更新于 2023-12-18 分类于计算机应用

python基础

数据类型

查看数据类型

type(date)

variable0='data'
variable1=100
variable2=True
variable3=variable1==variable2
print('variable0:',type(variable0))
print('variable1:',type(variable1))
print('variable2:',type(variable2))
print('variable3:',type(variable3))

#输出如下：
variable0: <class 'str'>
variable1: <class ''>
variable2: <class 'bool'>
variable3: <class 'bool'>

int整数。

任意大小的整数，包括负整数。python可以像数学中一样处理。

float浮点数。

小数。

str字符串。

文本格式。python中用引号‘’、“”、’'' '''括起来。

转义字符：如果在字符串之前加r,在能够原样的输出了。

如果字符串中已经包含了引号，需要用转义符来标识。单双引号相互嵌套时不需要用到转义
主要的转移字符有：\'、\''、\\、\n[new_line]、\t[tab]
单双引号可以互相嵌套不用转义。三引号表示按照输入的原格式输出。
引号前加r原始输出，即使是转义符号也原样输出。配合三引号，非常方便。

#如果字符串中包含有引号，就需要用在前面添加转义符'\'
print('You\'re ok!,my name is \'xiao yao xin\' ')
###输出：
You're ok!,my name is 'xiao yao xin'
#特殊转义符的使用：\n:换行，\t :制表符tab
print('You\'re ok!\nmy name is \t\'xiao yao xin\' ')
###输出：
You're ok!
my name is      'xiao yao xin'

#当符串内有很多换行，都用\n写的话不好阅读，为了简化，用
#（	‘’‘
#	contents
#	’‘’）
 print('''markdown
... vb
... \'\'c++\'\'
... bat
... ''')
###输出：
markdown
vb
''c++''
bat
# 单双引号相互嵌套时不需要用到转义
print('You say:'nice to meet you!'')
print('You say:'nice to meet you!!'')

#用 (r'‘’contents''')就更简单了。r:raw--原始输入内容; '''.....''':表示原格式输出
print(r'''
markdown,text
program
python
'excel'
'c++'
\jason\
\n\t
	''')
###输出：
markdown,text
program
python
'excel'
'c++'
\jason\
\n\t

布尔值

判断True或者False

True
True
 False
False
 3==3
True
 3>1
True
 3<2
False

运算符

and运算符是与运算，只有都是True结果才是True

 True and True
True
 True and False
False
 False and False
False
 False and True
False
 3>2 and 3>1
True
 3>2 and 3<5
True

or运算符是：或运算，只要其中一个为True结果就是True

 True or True
True
 True or False
True
 False or False
False
 5>3 or 3>4
True

not 运算是：非运算，是单目运算符，将True变成False，将False变成True

 not True
False
 not False
True
 not 1>5
True

空值

空值是python中的一个特殊值，用none表示。不能理解为0，因为0是有意义的，而none只是一个特殊的空值。

变量

与数学中的代数方程变量一致，只是在计算机程序中，不仅可以是数字，还可以是任意的数据类型。

变量在程序中用一个变量名称表示，用大小写英文、数字和_的组合，不能用数字开头。

a=1
print(a)
###输出：
1

t_007='100'
print(t_007)
###输出：
'100'

Answer=False	#变量Answer是一个布尔值
print(Answer)
###输出：
False

用=给变量赋值。同一个变量可以反复赋值，存储最后一个。

这种变量本身的类型都不固定的语言称之为动态语言，与之对应的就是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值时与类型不匹配则报错。

不能把赋值语句中的=等同于数学中的=。如下面的x=x+100在数学中是不成立的。

x=10			#将x赋值为10，此时x的值为10
x=x+100			#将x重新赋值为：x+100,右边的x就是上面已经赋值的x为10.左侧的x则为：10+100
print(x)
###输出：
110

print(x)
###输出：
110

最后，理解变量在计算机内存中的表示也非常重要。当我们写：

a='ABC'

时，Python解释器干了两件事情：

在内存中创建了一个'ABC'的字符串；
在内存中创建了一个名为a的变量，并把它指向'ABC'。

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码

a='i am xiaoyaoxin'
b=a
a='yxhsiao'
print(a)
print(b)
###输出：
yxhsiao
i am xiaoyaoxin

常量：名称是大写的。这是规则。

/：除法。结果是浮点数。即使能够整除也精确到1位小数。

//：除法，也称地板除。结果是取整。

%：余数。

** ：幂 a*a==a**2

Python的字符串

在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。有两个函数可以获取转换字符串。

ord()函数：获取字符的整数表示

chr()函数：把编码转行成字符

 ord('a')
97
 ord('中')
20013
 ord('中国')
 chr(97)
'a'
 chr(20013)
'中'
 print(chr(20013))
中

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。Python对bytes类型的数据用带b前缀的单引号或双引号表示：

x='abc'			#str类型
y=b'abc'		#bytes类型
len(x)
3
len(y)
3

格式化输出

占位符%，有%s,%d,%f(%0.1 ….)
.format函数

str(int)—>str ：将整型转换成字符串

str(False)—>str ：‘False’

int() ：取整数，整型。舍位。

`%？`占位符

占位符	替换内容
%d	整数 digit
%f	浮点数 float
%s	字符串 str
%x	十六进制整数

%.1f ：表示小数点后保留1位，四舍五入。

有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。占位符也是要在引号内的。

variable_0='xiaoyx'
variable_1='world'
variable_2=1000000
print('hello,%s' %variable_1)
print('hi,%s,you have $%d' %(variable_0,variable_2))

###输出：
hello,world
hi,xiaoyx,you have $1000000

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

1
2
3

print('%d、%d、%.0f、%.1f、%.2f、%.3f' %(3,15.563,15.563,15.563,15.563,15.563))
###输出：注意查看舍位、进位的规则。%d是舍位取整。%.0是四舍五入取整
3、15、16、15.6、15.56、15.563

如果字符串中本来就有%，需要用到转义，用%%表示一个%

Format( )函数

{0}、{1}

name=('xiaoyaoxin')
age=(43)
print('我是%s,今年已经%d岁了哦！' %(name,age))
print('我是{0},今年已经{1}岁了哦！'.format(name,age))
我是xiaoyaoxin,今年已经43岁了哦！
我是xiaoyaoxin,今年已经43岁了哦！

举例1：

# 题目要求：
电影：《不见不散》
票价：45.9
人数：48
总价：

# 先设置变量：
movie='《不见不散》'
price= 45.9
number= 48
total= price * number

# 写法1
message='''
电影：%s
票价：%.2f
人数：%d
总价：%.2f
'''%(movie,price,number,total)
print(message)

# 写法2
print('电影：' + movie)
print('票价：%.1f' %price)
print('人数：%d' %number)
print('总价：%.2f' %total)

# 写法3
print('电影：{}' .format(movie))
print('票价：{}' .format(price))
print('人数：{}' .format(number))
print('总价：{}' .format(total))

# 写法4
message='''
电影：{}
票价：{}
人数：{}
总价：{}
'''.format(movie,price,number,total)
print(message)

#输出的结果都是：
电影：《不见不散》
票价：45.90
人数：48
总价：2203.20电影：《不见不散》

票价：45.9
人数：48
总价：2203.20

电影：《不见不散》
票价：45.9
人数：48
总价：2203.2电影：《不见不散》

电影：《不见不散》
票价：45.9
人数：48
总价：2203.2

** 注意：占位符都是在包含在字符串中的。

input() 函数

一个内置模块函数。

python遇到input()时就等待键盘输入流，光标会在此处闪烁。程序在此阻塞，只有键盘回车后，下面的其他代码才会执行。才键盘输入的流给变量容器赋值。

input()函数，从键盘输入的都是字符串，即使输入的是数字，也被当作是str。这样就需要对输入的数字进行格式转换了，用到这个函数int()

举例说明：

print('''
******************
      照片库
******************
''')
user=input('please input your name:')
password=input('please input your password:')
print('hi! %s,you already logged in 。'%user)

print('if you want download the photo,please recharge!')
coins=input('input number:')
# 下面的这行是将输入的内容转换成整型数字。没有这行，下面引用变量占位符是%d就会报警
coins=int(coins)
print('you have recharge:$%d.you already go on download'%coins)

-------# 输出结果是：

******************
      照片库
******************

please input your name:m
please input your password:0
hi! m,you already logged in 。
if you want download the photo,please recharge!
input number:90
you have recharge:$90.you already go on download

print()函数

print内置函数的解释：sep end

print('name,age,gender')
name = 'xiaoyaoxin'
age = 43
denger = 'boy'
print(name,age,denger)
print('end')
# 每一个print结束后默认是换行的，非自负串之间的逗号默认是分隔符是空格。
# 因为内置的sep='space'，结尾追加了换行。end='\n'。
# 下面的例子更改了sep='-'和end='=='。
print(name,age,denger, sep='-',end='==')
print('end')
###输出：
name,age,gender
xiaoyaoxin 43 boy
end
xiaoyaoxin-43-boy==end

运算符

赋值运算符

= 。比如：variable_name = value。将右侧的value赋值给左侧的variable

扩展的赋值运算符：+= 、-= 、*= 、/=

num=5# 赋值5给num
print(num)
num+=3# num=num+5,此时赋值变成8
print(num)
num-=4# num=num-4
print(num)
num*=5# num=num*5
print(num)
num/=10# num=num/5
print(num)
#输出如下：
5
8
4
20
2.0

算数运算符

+、-、*、/ 同数学中的运算法则

扩展的算数运算符：** ：求幂、//：整除 %：求余数

a=9
b=4
num=a**b
num1=a//b
num2=a%b
print(num)
print(num1)
print(num2)

#输出如下：
6561
2
1

l1=['a'*3] # * 号在这里的作用，字符串成倍出现
print(l1)
#输出如下：
['aaa']

关系运算符

== != > < >= <= is is not

比较两者之间的关系是否成立，只返回两个值，True 或者False。is和not is 比较的是两个的地址是否相同，而不是两个的value

a=8
b=a*2/2
result1=a==b
result2=a!=b
result3=a is b# 是python对两个对象的比较，内存地址的比较
result4=a is not b
print('a==b:',result1)
print('a!=b:',result2)
print('id_a:',id(a))
print('id_b:',id(b))
print('a is b:',result3)
print('a is not:',result4)

#输出如下：
a==b: True
a!=b: False
id_a: 140732046759808
id_b: 3098296674288
a is b: False
a is not: True

查看对象内存地址：

同一地址的对象认为是相同的。python解释器每次运行装入一次数据，获得一批地址。同一次运行中，一个数据在内存中建立后可以被本次运行复用。

而终端中，只有小整数对象池(-5~256)被存储。其他的都每行结束即清除。

如何查看data的内存地址？

a=100
b=a
c=a+50-50
d=a*50/50
print('id_a:',id(a))
print('id_b:',id(b))
print('id_c:',id(c))# 加减运算后数值一样，
print('id_d:',id(d))# 乘除运算后数值一样。
print('id_5:',id(5))

#输出如下：
id_a: 140732011504384
id_b: 140732011504384
id_c: 140732011504384
id_d: 2122050856912
id_5: 140732011501344

逻辑运算符

位运算符

list[]

list：有序列表。可以随时添加和删除其中的元素。

list_name=[]

classmates=['zhang san','li si','whang wu']
print(classmates)
###输出：
['zhang san', 'li si', 'whang wu']

先给列表内容赋值。列表名是任意定义的，方括号，值可以是：str:’’，numble:数字,list:嵌套的列表。
list列表的索引是从0开始的。list_name[0/1/3...]
超出列表范围，indexError报错。要保证索引不越界。
最后一个元素的索引是：list_name[-1]

classmates=['aaa','bbb','ccc']
print(classmates)
print(classmates[1])#列表中序号1的元素
print(classmates[-1])#列表中倒數第一個
###输出：
['aaa', 'bbb', 'ccc']
bbb
ccc

print(classmates[3])#列表中倒數第一個
###输出：
Traceback (most recent call last):
  File '<stdin>', line 1, in <module>
IndexError: list index out of range #列表索引超出范围

list是可变的。
list_name.append（“content”）可以追加元素到末尾。
list_name.insert(i,”content”)，i是索引,插入到指定位置。

classmates=['aaa','bbb','ccc']
classmates.append('ddd')
print(classmates)
#输出如下：
['aaa', 'bbb', 'ccc', 'ddd']

classmates.insert(2,'BBB')
print(classmates)
#输出如下：
['aaa', 'bbb', 'BBB', 'ccc', 'ddd']

用.pop（i），i为空则删除末尾，可以删除末尾和指定位置的元素

classmates=['aaa','bbb','ccc']
classmates.pop()#没有制定索引号，默认最后一个
print(classmates)
#输出如下：
['aaa','bbb']

classmates.pop(0)
print(classmates)
#输出如下：
['bbb']

可以直接替换元素。指定索引号后重新赋值

list_name[i]=“new_contents ”

classmates=['aaa','bbb','ccc']
classmates[1]='aabb'#将索引号1的元素替换成'aabb'
print(classmates)
#输出如下：
['aaa', 'aabb', 'ccc']

list内元素的数据类型可以不同，也可以是另外一个list。类似一个二维数组。

you=['aab','bba']
we=['aaaa',888,True]
we.insert(1,you)#在we列表的1号位内插入you列表
print(we)
#输出如下：
['aaaa', ['aab', 'bba'], 888, True]

print(we[1])
#输出如下：
['aab', 'bba']

print(we[1][1])
#输出如下：
bba

如果一个list中没有元素，就是个空的list,他的长度是0。

1
2
3

them=[]
len(them)
0

list的函数

sorted,max,min

排序、求最大、最小值。只能支持数字类型的列表元素

#对列表进行排序，求最大、最小值。只能支持数字类型的ele
l0=[1,56,32,5,73,8]
l1=['aaa','bb',4,'a',2,'bbb']
print(sorted(l0))
print(max(l0))
print(min(l0))

len

计算列表的长度

l1=['aaa','bb',4,'a',[2,'bbb']]
print(len(l1))
print(l1[0],l1[2],l1[4])
print(l1[4][1])

#>>>
5
aaa 4 [2, 'bbb']
bbb

list

强制转行成list列表，可以将tuple转换成list

tuple_1=(1,2)
print(type(tuple_1))
print(type(list(tuple_1)))
#--》》
<class 'tuple'>
<class 'list'>

enumerate函数

主要用在遍历序列。内部有index value。还有一个start参数

list_1=[‘a’, 11,22, ‘aa’]
for i,j in enumerate(list_1):
    print( i,j)<br/>

# 输出：
0 a
1 11
2 22
3 aa

# 如果增加start参数：
list_1=['a',11,22, 'aa']
for i,j in enumerate(list_1,2):  #输出的序列值从设定的值起始
    print( i,j)
# 输出：
2 a
3 11
4 22
5 aa


for i,j in enumerate('abcdef',1):
    print(i,j)
# 输出：
1 a
2 b
3 c
4 d
5 e

list的增删改

l1=['aaa','bbb']
print('开始是这样的：',l1)
l1.append([1,'append']) # 在末尾添加一个ele
print('append: ',l1)
l1.insert(0,'insert') # 在指定位置插入一个ele
print('insert: ',l1)
l1.extend([666,'extend',888]) # 在末尾添加一组ele
print('extend: ',l1)
l1.pop(1) # 在删除指定位置的一个ele ，不指定index则默认删除末尾
print('pop: ',l1)
l1.remove(666) # 删除指定的元素，如果这个ele并不存在会报警。ValueError: list.remove(x): x not in list
print('remove: ',l1)
del l1[3]  # 在删除指定位置的一个ele
print('del: ',l1)
l1.clear()  # 清空列表
print('clear: ',l1)

#--->
开始是这样的： ['aaa', 'bbb']
append:  ['aaa', 'bbb', [1, 'append']]
insert:  ['insert', 'aaa', 'bbb', [1, 'append']]
extend:  ['insert', 'aaa', 'bbb', [1, 'append'], 666, 'extend', 888]
pop:  ['insert', 'bbb', [1, 'append'], 666, 'extend', 888]
remove:  ['insert', 'bbb', [1, 'append'], 'extend', 888]
del:  ['insert', 'bbb', [1, 'append'], 888]
clear:  []

tuple()

tuple：元组。和list类似但tuple一旦初始化就不能修改。其他基本与list一致。可以使用class[0]，class[1]。但不能赋值成其他元素

tuple_name1=('aaa','bbb','ccc')
tuple_name2=(1,3,5,7)
print(tuple_name1,tuple_name2)
#输出如下：
('aaa', 'bbb', 'ccc') (1, 3, 5, 7)

tuple_name1.append('ddd')#往元组内添加元素报警
Traceback (most recent call last):
    File '<stdin>', line 1, in <module>
    AttributeError: 'tuple' object has no attribute 'append'

tuple_name1.pop(0)#删除元组内的元素报警
Traceback (most recent call last):
    File '<stdin>', line 1, in <module>
    AttributeError: 'tuple' object has no attribute 'pop'

但是，要定义一个只有1个元素的tuple时,第一元素也后面要加,，否则定义的不是tuple。

tuple中的元素不可变，但是如果其中包含的有list，那么list中的元素则是可边的。因为tuple并没有变，变的是其中的list。

a=(110,'flower',['dance',6])
print(a)
print(a[2][0])
a[2][0]=(2020)
a[2][1]=('sing')
print(a)
print(a[2][0])
#输出如下：
(110, 'flower', ['dance', 6])
dance
(110, 'flower', [2020, 'sing'])
2020

实例：

L = [
['Apple', 'Google', 'Microsoft'],
['Java', 'Python', 'Ruby', 'PHP'],
['Adam', 'Bart', 'Lisa']
    ]
print(L[0])	#打印的是一个列表
#输出如下：
['Apple', 'Google', 'Microsoft']

print(L[1])
#输出如下：
['Java', 'Python', 'Ruby', 'PHP']

print(L[2][1])#打印的是一个列表中的一个元素
#输出如下：
Bart

list and tuple 的总结

	list	tuple
格式	list_name[value] 1 .list_name:任意命名 2 .方括号 3 .value: 多种数据类型：str:带引号，num:数字，list:嵌套的列表	tuple_name(value) 区别：小括号元组内的元素ele不能增删改。
定义	list_name=[] 定义一个空列表 list_name=[‘abc’, ‘cbc’, 1860, [‘aaa’, ‘bbb’]] 索引号index是从 0 开始的。	tuple_name=() 空元组 tuple_name=(‘aaa’,555)
运算符	+ : 列表合并： l0=l1+l2, 合并了两个列表l1和l2 * : 元素成倍数出现 l0[‘w’*3]—- ==lo[‘w’, ‘w’, ‘w’ l1=l0 — l1的结果相当于3个l0 in :判断某个ele是否存在列表中，返回值True/False not in :与in 对立 is : 判断两个列表的地址是否相同。两个内容相同的列表不一定是is关系。其中一个列表直接赋值给另一个列表的时候才是is的关系了两次赋相同的值则已经在内存中存储了两个地址，所以不是is not is : 与is对立
函数	1. len( list_name) :计算列表的长度 2. sorted( list_name): 列表排序 3. max( list_name) :列表最大值,列表内只能是数字。 4.min( list_name): 列表最小值 5. list(): 强制转换成列表类型。list( tuple_name) 6. enumerate( list_name):枚举， index/ value	len(): sorted() max min tuple
增删改查	1.添加元素elements : 1.1 list_name.append(add ele)—末尾添加1个ele 1.2 list_name.extend([])—末尾添加一组元素 append只能添加一个ele,或1个list extend能添加一组ele，用[]括起来，其中可以包含多种数据类型 1.3 list_name.insert(index, ele)–指定位置调价元素 2. 删除元素 2.1 del list_name[index]—删除第几个元素 2.2 list_n.remove(ele) —-删除列表中指定的obj 2.3 list_name.pop(index)— 不指定index则删除末尾 2.4 list_n.clear —清空列表中的所有ele( 3.修改元素 list_name[index]=new value	不能增删改。如果元组中包含有一个列表，那么这个列表内的ele是可以修改的。因为其实修改的是元组内这个列表的ele
其他

list的嵌套:

a=[1,2,3,4,5]
b=[11,22,33,44,55]
c=[a,b]
print(c)

---->
[[1, 2, 3, 4, 5], [11, 22, 33, 44, 55]]

if条件判断

if语句是条件判断，如果条件为true就返回什么值，否则返回什么值。语句有缩进规则。它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif 和else。

if语句中elif 、else 都是可选的，可以没有。

格式：

a = 5
if a >= 5:
	print('you are', 'good')
else:
	print('you are', 'less')
#输出如下：
you are good

a = 5
if a >= 5:
	print('A')
elif a >= 3:
	print('B')
else:
	print('Low')
#输出如下：
A

举例：

小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，并根据BMI指数：

低于18.5：过轻
18.5-25：正常
25-28：过重
28-32：肥胖
高于32：严重肥胖

a = 1.73
b = 80.5
BMI = b/(a**2)
if BMI < 18.5:
	print('你的BMI指数是：', BMI)
	print('体重过轻')
elif BMI >= 18.5 and BMI <= 25:
    print('你的BMI指数是：', BMI)
    print('体重正常')
elif BMI > 25 and BMI <= 28:
    print('你的BMI指数是：', BMI)
    print('体重过重')
elif BMI > 28 and BMI <= 32:
    print('你的BMI指数是：', BMI)
    print('体重肥胖')
elif BMI >32:
    print('你的BMI指数是：', BMI)
    print('严重肥胖')
#输出如下：
你的BMI指数是： 26.896989541915868
体重过重

循环

for x in …

for variable in [range]循环就是把每个元素依次代入变量，然后执行缩进块的语句。

从for开始到最后是个缩进语句是一个循环。

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
	sum = sum + x
print(sum)
#输出如下：
55

range(i)函数：一个序列函数。生成整个序列。从0-i。range(1,5)生成1～5。

sum=0
for x in range(101):  # 设定变量x在range(101):0~101的范围内遍历。
	sum = sum + x
print(sum)
#输出如下：
5050

a=[x for x in range(12) if x%2]
b =[x for x in range(12) if x not in a ]
print(a)
print(b)
#---->
[1, 3, 5, 7, 9, 11]
[0, 2, 4, 6, 8, 10]

while

while循环，只要条件满足，就不断循环，条件不满足时退出循环。

从while开始到最后一个缩进语句结束为一个循环。

sum = 0  # 初始化sum
n = 99  # 给变量n赋值
while n > 0: # 当n>0时，执行下面缩进语句，否则往下执行
    sum = sum + n  # 新的sum=之前的值+当前的n值
    n = n - 2  # 新的n=当前的n-2
print(sum)  # 条件不满足后，输出当前sum值

# 请利用循环依次对list中的每个名字打印出Hello, xxx!：
L = ['Bart', 'Lisa', 'Adam']
n = 0
while n <= 2:
    print('Hello', L[n], '!')
    n = n+1
print('end')

while 中的break：

break语句可以提前退出循环。下例中本来是要依次输出1～100的数字的，但是用一个if语句加break语句退出了循环。

# 输出1 to 100
n = 1
while n <= 100:
    print(n)
    n = n + 1
print('END')

# 输出1 to 10
n = 1
while n <= 100:
    if n > 10:
        break
    print(n)
    n = n + 1
print('END')

while 中的c ontinue:

continue语句，跳出当前循环的本次循环，开始下一次循环。

# 输出1～10范围的奇数
n = 0
while n < 10:
    n = n+1
    if n % 2 == 0:  #如果为偶数，执行下面的continue
    	continue#跳到下一个循环，不执行下面的语句.
    print(n)

dict字典

dict() 函数用于创建一个字典。字典中key 与value成对出现

字典的创建:

创建空字典 a={} 或者 a=dict()
给写入数据:a={‘key1’:value1 , ‘key2’:value2 , …ext}
用两个列表分别导入key 和 value. d=dict(zip(lst1,lst2)
两个列表长度可以不相等,创建时自动删掉多余的不成对的key或者value

a = {}
b={'a':123,'b':234,'c':345}
c=dict(a=123,b=234,c=345)
# 用两个列表创建字典
x = ['A', 'B', 'C', 'D', 'E', 'F']
y = [121, 597, 971, 278, 396, 451]
d = dict(zip(x, y))


print(''' a的类型是:{}
a的数据包含:{}
b的数据包含:{}
c的数据包含:{}
d的数据包含:{}
	'''.format(type(a), a, b, c,d))
--->
a的类型是:<class 'dict'>
a的数据包含:{}
b的数据包含:{'a': 123, 'b': 234, 'c': 345}
c的数据包含:{'a': 123, 'b': 234, 'c': 345}
d的数据包含:{'A': 121, 'B': 597, 'C': 971, 'D': 278, 'E': 396, 'F': 451}

读取字典的key或者value

keys():返回字典的key

values():返回字典的value

x = ['A', 'B', 'C', 'D', 'E', ]
y = [121, 597, 971, 278, 396, 451]
d = dict(zip(x, y))

a=[]
for i,j in d.items():
	a.append([i,j])
print(a)

--->[['A', 121], ['B', 597], ['C', 971], ['D', 278], ['E', 396]]

set 集合

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

set 语法：class set([iterable]) iterable – 可迭代对象

set 可以对单个元素或者列表去重
set后的列表类型变成集合.
做交集,并集,差集运算必须是集合
set做运算用到的是符号 &, /, -
集合本身不支持索引,要读取集合的元素,先将其转成列表.

x = set('runoob')
y = set('google')
a = x & y         # 交集
b = x | y         # 并集
c = x - y         # 差集
print('''x的集合是:{}
	y的集合是:{}
	x和y的交集是:{}
	x和y的并集是:{}
	x和y的差集是:{}
	'''.format(x, y, a, b, c))

--->
x的集合是:{'u', 'n', 'o', 'r', 'b'}
	y的集合是:{'e', 'g', 'o', 'l'}
	x和y的交集是:{'o'}
	x和y的并集是:{'u', 'n', 'o', 'g', 'e', 'r', 'b', 'l'}
	x和y的差集是:{'u', 'n', 'r', 'b'}

intersection() 交集

intersection() 方法用于返回两个或更多集合中都包含的元素，即交集

intersection() 方法语法：set0.intersection(set1, set2 … etc)

intersection针对的对象必须是集合,如果是列表,必须先用set转换成集合

k = set([x for x in range(1, 10)])
x = {x for x in range(1, 10)}
y = {x for x in range(1, 10) if x % 2}
z = {x for x in range(1, 10) if x > 5}

a = k.intersection(y)
b = k.intersection(x, y, z)
print('''	k的集合是:{}
	x的集合是:{}
	y的集合是:{}
	z的集合是:{}
	k和y的交集是:{}
	k和x,y,z的交集是:{}
	'''.format(k, x, y, z, a, b))

--->
	k的集合是:{1, 2, 3, 4, 5, 6, 7, 8, 9}
	x的集合是:{1, 2, 3, 4, 5, 6, 7, 8, 9}
	y的集合是:{1, 3, 5, 7, 9}
	z的集合是:{8, 9, 6, 7}
    k和y的交集是:{1, 3, 5, 7, 9}
	k和x,y,z的交集是:{9, 7}

[Finished in 1.2s]

difference() 差集

difference() 方法语法：set0.difference(set1)

只针对集合的运算.

x = {x for x in range(1, 10)}
y = {x for x in range(1, 10) if x % 2}

a = x.difference(y)
print('''	x的集合是:{}
	y的集合是:{}
	x和y的差集是:{}
	'''.format(x, y, a))
--->
	x的集合是:{1, 2, 3, 4, 5, 6, 7, 8, 9}
	y的集合是:{1, 3, 5, 7, 9}
	x和y的差集是:{8, 2, 4, 6}

注释：

单行注释。#开头。
多行注释。

'''

……

''’

常见的报错

SyntaxError：语法无效

语言的语法是一组规则，这些规则定义了语言的哪些部分可以出现在哪个位置。可以这么说，如果将选项卡A插入插槽B，则将创建一个语法无效的语句。由于Python中有很多不接受大多数制表符的插槽，因此生成语法错误并不难。

这是导致此消息的一些常见错误：

忘记要打印的参数周围的括号``
在if语句中的条件结尾处忘记冒号
尝试使用保留字作为变量名

IndentationError：应缩进的块

程序语句的缩进对于代码的可读性至关重要。大多数编程语言都允许缩进，但不强制执行缩进。Python用铁腕将其实施。每当您在语句中包含代码的情况（例如定义main（）函数的代码）时，“内部”代码都必须缩进，并且必须一致缩进。如果您忘记缩进，则会看到此错误。

此错误的一些常见原因包括：

忘记缩进复合语句中的语句（例如if和for的正文）
忘记缩进用户定义函数的语句

IndentationError：意外缩进

如“预期缩进的块”部分所述，Python不仅坚持缩进，而且坚持一致的缩进。您可以自由选择要使用的缩进空格的数量，但随后需要坚持使用。如果您将一行缩进4个空格，然后将下一行缩进3个（或5个，19个或…），则会出现此错误。

此错误的一些常见原因包括：

忘记缩进复合语句中的语句（例如if和for的正文）
忘记缩进用户定义函数的语句

NameError：全局名称“ —”未定义

Python知道某些名称的用途（例如诸如print之类的内置函数的名称）。程序中定义了其他名称（例如变量）。如果Python遇到无法识别的名称，则可能会出现此错误。

此错误的一些常见原因包括：

忘记在另一个语句中使用变量之前给它赋值
拼写了内置函数的名称（例如，键入“ inpit”而不是“ input”）

TypeError：无法将“ int”对象隐式转换为str

Python变量“知道”它们持有的值的种类，这使Python可以在您尝试做奇怪的事情时告诉您，例如，使用加法运算符将数字和字符串组合起来（answer =“ Hello” + 1）。

导致此错误的常见原因是，当要求用户从键盘输入数字值时，忘记将eval（） 与input（）一起使用。

如何正确的养成一个习惯？

硬度换算表

使用pandas的必要条件

安装必要的模块：

其他功能需要的模块

测试环境ok？

功能概括

操作excel的行和列

用loc：

用iloc：有序列功能

数据筛选功能

修改值

添加列

python基础

数据类型

查看数据类型

int整数。

float浮点数。

str字符串。

布尔值

运算符

空值

变量

Python的字符串

格式化输出

%？占位符

Format( )函数

input() 函数

print()函数

运算符

赋值运算符

算数运算符

关系运算符

查看对象内存地址：

逻辑运算符

位运算符

list[]

list的函数

sorted,max,min

len

list

enumerate函数

list的增删改

tuple()

list and tuple 的总结

list的嵌套:

if条件判断

循环

for x in …

while

while 中的break：

while 中的c ontinue:

dict字典

字典的创建:

读取字典的key或者value

set 集合

intersection() 交集

difference() 差集

注释：

常见的报错

SyntaxError：语法无效

IndentationError：应缩进的块

IndentationError：意外缩进

NameError：全局名称“ —”未定义

TypeError：无法将“ int”对象隐式转换为str

margin

`%？`占位符