python学习笔记

前言：本篇文章是作者在B站学习python时候的笔记，所以也会写一些个人感悟，所观看B站的教学视频是python标签中的第一位教学视频，希望笔记对大家都有所收获。

一、print函数、转义字符

1.1、首先是对print函数进行的解释以及举例

1、print可以直接输出字符串，但是要用引号把字符串引起来，不引起来是的话错误的

print('hello world')
#print(hello world)		//这个就是错误的

2、print可以直接输出数字和表达式，不需要引号引起来，直接书写就好

print(520)
print(95.2)
print(3+1)

3.print可以将输出的值保存到文件当中去，因为print中有file这个属性，所以可以将输出的值输出到file里面，而不用输出到显示屏上
代码中的 ’ a+ '表示如果文件不存在就直接创建，存在就在文件内容的后面继续追加

fp=open('./text.txt','a+') 
print('hello world',file=fp)
fp.close()

4.print输出之后会自动换行的，所以如果你想要不换行的话，得需要在一个print里面输出所有东西

print('hello','world')

1.2、针对于转义字符的讲解与举例

1.转义字符：

\n:代表换行，相当于newline

print('hello\nworld')

\r 就代表回车，相当于回到这一行的首个字符,之前的相当于没写到，相当于return

print('helloooo\rworld')

\b：就代表退格，往前删一个单元，相当于backspace

print('hello\bworld')
print('helloo\bworld')

\t：就代表tab，一般是以四个字符为一个单元的，缺几个补几个，不缺的话，就写四个,比如下面的例子，会发现之间的空格数都是不同的

print('hell\tworld')
print('hello\tworld')
print('helloo\tworld')
print('hellooo\tworld')

:在字符串里面，如果你想用\的话，就得使用转义字符\，一个\需要一个转义，两个杠就需要两个\

print('http:\\www.baidu.com')   #仅仅只是用来举例，不表示正确的网址，正确的网址下面应该是//，不是\\

print('http:\\\\www.baidu.com')

#’:在字符串里面，如果需要使用‘的话，需要加上转义字符哦

print('the teacher said\'good morning\'')
#print(print('the teacher said'good morning'') //,这样是会报错的

#r:在字符串里面，如果需要使用它原来的意思，不把他表示成转义字符后面的值的话，就需要加入r，来表示原字符的值,但是有一个条件，使用R之后，最后一个字符不能是\ ,代码可以是多个\ 就可以

print(r'http:\\\\www.baidu.com')
#print(r'http:\\\\www.baidu.com\')	//因为这个字符串末尾是\，所以这句话是错误的，结尾不能是\
print(r'http:\\\\www.baidu.com\\')

二、字符编码、关键字、变量、数据类型、注释

2.1、二进制与字符编码

主要有ascll编码和GBK编码，有什么utf-8编码和unicode编码，这四种编码的区别和目的如下
acsll编码使用128个字符来表示英文的常见字符，无法表示汉字或者其他国家的语言，中国就搞了自己的国家的GBK编码，用来表示中国的常用字符，但是GBK包含的字符不全，中国后来有引入了GB18030来表示更多的中国字符，Unicode是为了解析各个国家的编码的不同，而设定的一个规定的标准，但是这个标准又不太好，因为他规定了所有字符都是两个字节来解析的，这样就会很慢，所以有引入了什么utf-8这种标准，让英文一个字节来解析，中文三个字节来解析，来帮助Unicode这种标准,一般情况下，如果不指定编码的话，都是默认unicode

2.2、标识符和关键字：

1.python的标识符命名规则和C一样，可一起记忆

2.如何查看python中的关键字?

 import keyword
 print(keyword.kwlist)

2.3、 变量的定义和使用

变量有三部分组成：变量名，运算表达式，值

name='楚留香'
print(name,id(name))
print(name,type(name))
print(name)

name里面其实保存的是id值，这个id值同时保存在name和’楚留香‘这两个里面，是相同的，当print(name)的时候，会从name里面id对应的值找到‘’楚留香，然后输出，一般情况下，只会有id，类型，还有值保存在你命名的变量内存里面。变量名相当于指针，多次赋值的话，指针对应的id值会变，就会指向不同的value对应的id值

name='楚留香'
name='张三'
print(name,id(name))
print(name,type(name))
print(name)

2.4、数据类型

数据类型：int float bool str

• 1.整型：int

  整数可以表示为二进制0b、八进制0o、十进制、十六进制0x。

• 2.浮点型：float

  使用浮点型的变量相加之后可能会存在值不准确的问题，可以考虑引入decimal模块,decimal其实也是一种数据类型，是十进制的数据类型，实际上就是将flaot类型进行一次强制类型转换，不让他变成浮点数相加，就不会产生浮点数相加的误差。

n1 = 1.1;
n2 = 2.2;
print(n1+n2)  #结果是3.3000000000000003

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))  #结果是3.3

对于decimal模块而言，可以使用其自带的getcontext().prec这个属性来改变其精度。假设精度为1，相当于只有一个数字，依次类推，他的默认精度是28位。

他和浮点数类型的区别就在于他更加精确，所以当你需要表示的数很精确的时候，必须采用decimal，浮点数随便可以 表示的数的范围很大，但是不太精确，都是近似的，所以一般用decimal表示精确的值

import decimal
decimal.getcontext().prec=28
n1=1.1
print(n1,type(n1))
n2=2.2
print(n1+n2)
#print(Decimal('n1')+Decimal('n2')) 这样是不行的，因为他是数据类型，不可以把变量名放进去让他类型转换，你只可以放变量的值进去进行类型转换

print(decimal.Decimal('1.1')+decimal.Decimal('2.2'))
print(decimal.getcontext().prec)

m1=decimal.Decimal('1.1')
m2=decimal.Decimal('2.2')
print(m1+m2)

• 3.布尔类型：

  就是只有两个值：True和False
  和其他语言不同的是，它可以直接被当成整型来计算，True默认为1，False默认为0,因为python严格区分大小写，所以true的T必须是大写，false的F也必须是大写

m1=True
m2=False
print(m1,type(m1))
print(m2,type(m2))
print(m1+1)                                     #结果是2
print(m2-1)                                     #结果是-1

• 4.str数据类型

  字符串定义可以使用单引号，可以使用双引号，也可以使用三引号，三引号和其他引号不同的是，他的字符串的值可以分布在两行输入或者显示

str1='人生苦短，我用python'
str2="人生苦短，我用python"
str3='''人生苦短，我用python'''
str4="""人生苦短，我用python"""
str5='''人生苦短，
我用python'''
str6=""""人生苦短，
我用python
"""
print(str1)
print(str2)
print(str3)
print(str4)
print(str5)
print(str6)

• 5.str类型转换-------str() 将其他类型转成str类

一般是用在连接符的情况下，因为连接符要求连接前后的数据类型必须一致，所以采用类型转换。

name='张三'
age=20
#print('我的名字是：'+name+'，我的年龄是多大：'+age)     #因为连接符前后数据类型不一样，所以报错
print('我的名字是'+name+'，我的年龄是：'+str(age))

# str() 将其他类型转成str类型
a=10
b=198.8
c=True
print(type(a),type(b),type(c))
print(str(a),str(b),str(c))
print(type(str(a)),type(str(b)),type(str(c)),)

• 6.int类型转换

一般只能转换字符串类型为整数的值，和浮点数转换的时候需要舍去小数（不会四舍五入），在转换布尔类型的时候，可以正常转换

s1='98'
s2='98.8'
s3='tom'
f1=98.8
b1=True
b2=False
print(s1,s2,s3,f1,b1,b2)
print(int(s1))
#print(int(s2))                不是整型，不能转换
#print(int(s3))                #只能转字符串为整数的
print(int(f1))                 #转完之后直接取整
print(int(b1))
print(int(b2))

• 7.浮点数类型转换：

float() 可以将除了字符串为文字的部分无法转外，其他都可以转换，另外，当转换的值为整数的时候，会自动补零，不管这个整数是什么类型的

s1='1980'
s2='198.59'
s3='hello'
i1=95
b1=True
b2=False
print(float(s1))                #他转换为1980.0，因为是整数，所以带0
print(float(s2))                #转换为198.59
#print(float(s3))              #无法转换，因为是文字
print(float(i1))                #他转换为95.0，因为是整数，所以带0
print(float(b1))                #他转换为1.0，因为是整数，所以带0
print(float(b2))                #他转换为0.0，因为是整数，所以带0

2.5、注释方式

有三种注释方式：
1.第一种就是很常见的 # 来注释
2.第二种就是三引号来注释，因为三引号表示的字符串可以换行啊，所以可以表示注释，例如

'''嘿嘿嘿，
我是一个
注释哦
'''

3.第三种就是在pyth文件的首行来规定这个python的文件的打开方式，就比如这个python文件的第一行，就表示了他是什么格式打开的

#coding:utf-8
print('hello world')

python默认存储为UTF-8，在文件开头注释 #coding:gbk 该文件就默认存储为GBK了

三、运算符

3.1 input函数的使用

!!!他的返回值类型一定是str类型

m1=input('please input the first word:')
m2=input('please input the second word:')
print(int(m1)+int(m2))


n1=(input('please input the first word:'))
n2=(input('please input the second word:'))
print(int(n1)+int(n2))

3.2、赋值运算符

它支持四种运算：

1.支持连续赋值，就是连续等于，例如

a=b=c=20

2.支持参数赋值

m=20
print(m)
m+=10           #30
print(m)
m-=10               #20
print(m)
m*=3              #60
print(m)
m/=5              #12
print(m)
m//=2              #6
print(m)
m%=2              #0
print(m)

3.支持系列解包赋值，实际上就是类似这样可以直接给多个变量赋值，等号左边和右边的数量应该相同
!!!一般用于交换两个变量的值

o,p,q=10,20,30
print(o,p,q)

4.交换两个变量的值

a,b=10,20
a,b=b,a #实现了交换

3.3、算数运算符

加：+ 减：- 乘：* 除：/

幂次方：**，比如2的三次幂，就是2* *3

整除：//，比如8//3=2，但是有特殊情况，当整除的被除数和除数符号不相同时，结果向下取整

取余：%，有特殊情况，当取余的被除数和除数符号不相同的情况下，余数=被除数- 除数 * 商

print(1+1)          #输出2
print(1-8)          #输出-7
print(1*8)          #输出8
print(1**8)         #输出1
print(2**5)         #输出32
print(9/4)          #输出2.25
print(9/(-4))          #输出-2.25
print(9//4)          #输出2
print(9//(-4))          #输出-3
print(9%4)              #1
print(9 % -4)            # 9-(-4) * (-3)  = -3 
print((13%(-5)))         # 13-(-5)*(-3) = -2
print((-13)%5)           # -13-5*(-3) = 2

3.4、比较运算符

所有的比较运算符，他的返回值都是布尔型，True或者False

大于：> 小于：< 等于：== 大于等于：>= 小于等于：<= 不等于：!=

is：用来比较两个变量保存的ID是否是相同的

is not：用来比较两个变量保存的id是否是相同的

a=10
b=10
c=10.0
print(a == b)  #True  比较的是值value
print(a is b)  #True  比较的是id
print(a is c)  #False
print(a is not b)  #False
print(a is not c)  #True

lst1=[11,22,33]
lst2=[11,22,33]
print(lst1 == lst2)  #True  比较的是值value
print(lst1 is lst2)  #False 比较的是id，注意这里数组

3.5、布尔运算符

并且：and
或者：or
相反：not 是针对布尔类型的操作数取反
in ：可以用来检查某个字符是否在这个字符串里面
not in：可以用来检查某个字符没有在这个字符串里面
！！！！！！！！！！！！！布尔运算符一般也是对布尔类型操作数进行运算的

a=1
b=2
print(a==1 and b==2)  #True
print(a<1 and b<2)    #False
print(a==1 and b<2)   #False
print(a!=1 and b==2)  #False

print(a==1 or b==2)
print(a<1 or b<2)

t=True
f=False
print(not t)  #False
print(not f)  #True

m='hello world'
print('h' in m)  #True
print('h' not in m)   #False
print('h' in 'hello')   #True

3.6、位运算(位是指二进制的每一位)

按位与&：就是让a&b。让a的每一位与b的每一位进行与运算，得到的值为按位与后的值

按位或|：就是a|b。让a的每一位与b的每一位进行或运算，得到的值为按位或后的值

左移运算符：就是a<<1，相当于a左移一位，相当于a乘以2。高位溢出，低位补0

右移运算符：就是a>>1，相当于a右移一位，相当于a除以2。低位截断，高位补0

左移解释：高位溢出，低位补0

右移解释：低位截断，高位补0

print(4&8)          #结果为0   4的二进制为0100  8的二进制为1000 按位与全是0
print(4&12)         #结果为4
print(8&9)          #结果为8

print(4|8)          #结果为12 4的二进制为0100  8的二进制为1000 按位或为1100，所以是12
print(4|12)         #结果为12
print(8|9)          #结果为9

print(4<<2)         #结果为16
print(4>>2)         #结果为1

3.7 、运算符的优先级

优先级最最高的是括号
优先级最高的是算数运算符，算数运算符里面，要先算幂运算，再算乘除，再算加减
再就是是位运算符，先做左移右移，再算按位或，按位与，
再然后是比较运算符，把算得的结果是true或者false送给布尔运算符
最后是布尔运算符

四、程序的组织结构

4.1、顺序结构

什么是顺序结构呢？比如说

                                                                                                                                                
'''把大象装冰箱需要分几步？'''

print('----------------------程序开始')
print('1.打开冰箱')
print('2.把大象放进去')
print('3.关闭冰箱')
print('-------------------------程序结束')

4.2、对象的布尔值

python一切皆对象，所有对象都有一个布尔值

False：False、数值0、None、空字符串、空列表（[]、list()）、空元组（()、tuple()）、空字典（{}、dict()）、空集合（set()）

其它对象的布尔值均为True

print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([]))       #空列表
print(bool(list()))   #空列表
print(bool(()))        #空元组
print(bool(tuple()))  #空元组

4.3、单分支结构

就比如说这个代码，顺序结构实际上就是程序从上到下依次前去执行的结构

'''就比如从银行取钱'''
money = 10000
get = int(input('请输入您要取的金额：'))
if money >= get:
    money = money - get
    print('恭喜你，取钱成功，剩余金额为：', money)

4.4、双分支结构

相当于一个分岔口，有两条路可以选择，你可以走其中一条

'''从键盘录入一个数字，判断该数字是奇数还是偶数，并且输出'''
a=int(input('请输入你想要查询的数字：'))
if a%2 == 0:
    print(a,',他是一个偶数')
else:
    print(a,'，他是一个奇数')

4.5、多分支结构

多分支结构里面，一般使用elif来代替C语言里面的else if
最后的一个else是可以省略的，即分支结构里面可以全是elif,elif后面必须加入判断语句

num=int(input('请输入你要查询的分数：'))

if num >= 90 and num <=100:
    print("成绩是在90分以上")
elif num>=80 and num <90 :
    print('成绩是在80分以上')
elif num>=70 and num <80:
    print('成绩在70分以上')
elif num >=60 and num <70:
    print('成绩在60分以上')
elif num<60 and num >=0:
    print('你没有及格哦')
else:
    print('对不起.输入有误')

当然,除了上面这种写法之外,还有一种写法,就是python语言特有的写法,就是可以把这种and连接的判断语句并到一起,修改之后如下

num=int(input('请输入你要查询的分数：'))

if 90<=num <=100:
    print("成绩是在90分以上")
elif 80<=num <90 :
    print('成绩是在80分以上')
elif 70<=num <80:
    print('成绩在70分以上')
elif 60<=num <70:
    print('成绩在60分以上')
elif 60>=num>=0:
    print('你没有及格哦')
else:
    print('对不起.输入有误')

4.6、 嵌套if的使用

就是在一个if的下面再写一个if,在运行的时候,会层层判断进去,直到找到你所要符合的条件

'''价格的数据类型,可以是float,也可以是decimal,但最好不要是int'''

'''判断是否为会员,会员与非会员之间有大的折扣差别
    是会员的话,如果购买金额大于200,打八折,大于100,打9折,否则不打折.
    非会员的话,大于200打9.5折,其余不打折'''
import decimal
decimal.getcontext().prec=9
a=input('请问你是会员吗?(y/n):')
b=decimal.Decimal(input('请输入你购买的金额:'))

if a=='y':
    if b>=200:
        print('本次消费:',b*decimal.Decimal(0.8))
    elif 100<=b<200:
        print('本次消费:',b*decimal.Decimal(0.9))
    else:
        print('本次消费',b)

else:
    if b>=200:
        print('本次消费:',b*decimal.Decimal(0.95))
    else:
        print('本次消费',b)

还有一种实现方法

a=input('请问你是会员吗?(y/n):')
b=float(input('请输入你购买的金额:'))

if a in'y':
    if b>=200:
        print('本次消费:',b*0.8)
    elif 100<=b<200:
        print('本次消费:',b*.9)
    else:
        print('本次消费',b)

else:
    if b>=200:
        print('本次消费:',b*0.95)
    else:
        print('本次消费',b)

4.7、条件表达式

语法格式如下：

x if 判断语句 else y

如果判断语句为真,则执行X语句,如果判断语句为假,则执行y语句,条件表达式中间没有任何逗号或者冒号

m=1 if 3<=2 else 2
print(m)
a=int(input('请输入第一个数:'))
b=int(input('请输入第二个数:'))

'''n=a if a>=b else b
print(n)'''

print(a if a>=b else b)

4.8、pass语句

其实就是一个占位符号,一般用在代码没想好写什么的时候使用,就是先占一下位置,让代码保持正确格式的作用

m=int(input('请输入第一个数:'))
n=int(input('请输入第二个数:'))
if m>n:
    pass
else:
    pass

五、程序流程控制

5.1 、range函数

这个函数生成的是一个整数序列,他的返回值是一个迭代器对象,所以直接print它是没有用的,输出不了里面的值

所以要看它里面的值的话,得把他列表化,然后print才可以打印出来

range函数一般有三种书写方式:

1.如果只写一个参数,那么就默认这个参数是终止值,他的起始值默认是0,他的步长默认是1,就会产生一个以0开始,到终止值-1且步长为1的列表序列

a=range(20)
print(a)                    #输出range(0, 20)
print(list(a))              #输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

2.如果只写两个参数,那么这两个参数的第一个默认为起始值,第二个数默认为终止值,步长还是默认为1,会产生以第一个数为起始值,第二个数为终止值的步长为1的列表序列

a=range(10,20)
print(list(a))              #输出[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

3.如果写三个参数,那么这三个参数中第一个参数默认为起始值,第二个参数默认为终止值,第三个参数默认为步长,他就会产生以第一个数为起始值,第二个数为终止值,第三个数为步长的列表序列

a=range(10,20,3)
print(list(a))              #输出[10, 13, 16, 19]

4.一般用in 或者not in来判断在range生成的序列里面有没有这个数

print(10 in list(a))            #输出为True
print(15 in list(a))            #输出为False
print(10 in a)                  #输出为True,相当于使用了这个函数,所以就会计算这个函数,所以才会使True
print(1 in a)                  #输出为True

5.2 、while循环

while的具体用法和C一样,无出其右罢了，下面只有几个代码示例

'''计算0到4的和'''
b=0
a=0
while a<=4:
    b=b+a
    a=a+1
print(b)

'''计算1-100之间的偶数和：方法一'''
'''sum=0
a=0
while a<=100:
    sum=sum+a
    a+=2
print('1-00之间的偶数和为:',sum)'''


'''#方法2
sum=0
a=0
while a<=100:
    if a%2==0:	#可以直接写a%2 因为不等于0，bool类型就为1，就true，就是算的奇数的和		
        sum = sum + a
    a+= 1
print('1-00之间的偶数和为:',sum) '''

sum=0
a=0
while a<=100:
    if not bool(a%2):			#bool将得到的对象强制转换成布尔类型True或者False
        sum = sum + a
    a+= 1
print('1-00之间的偶数和为:',sum)

5.3 、for in 迭代对象

运行顺序如下:

首先它会将迭代对象的值赋值给item,然后执行次数就是迭代对象的迭代次数,目前迭代对象只包括range函数和字符串，列表（由于目前我只学到这些，就先写这些）

如果你不需要使用item,可以将其替换成_,这样,你就相当于只是使用了迭代次数.

for item in 'Python':
    print(item)

'''sum=0
for i in range(0,101,2):
    sum+=i
print(sum)'''

sum=0
for i in range(101):
    if  i%2==0:
        sum+=i
print(sum)

比如：求出100-999之间所有的水仙花数

在写水仙花数的时候,一定需要注意一点,python里面的/表示除法,不是整除,不能惯用C语言的知识去写

'''import  decimal
for item in range(100,1000):
    m=item
    a=decimal.Decimal(item)%decimal.Decimal(10)
    item=decimal.Decimal(item)//decimal.Decimal(10)
    b=decimal.Decimal(item)%decimal.Decimal(10)
    c=decimal.Decimal(item)//decimal.Decimal(10)
    if a**3+b**3+c**3==m:
        print(m)'''

print('--------------其实没有必要写decimal的类型')

for item in range(100, 1000):
   
    ge = item %10 #得到个位上的数
    shi = item//10%10  # 十位
    bai = item // 100  #百位
    if ge ** 3 + shi ** 3 + bai ** 3 == item:
            print(item)

5.4、break

是用来结束循环的一个语句,一般只用在循环结构中,分支和选择结构中,不用break
他只负责控制自己所在的循环,如果在多重循环中,他只负责结束自己循环的部分,不结束外层循环

'''输入密码,输入正确立即退出,输入错误,可以尝试三次'''

print('------------for_in---------------')
for item in range(3):
    pwd=input('请输入你的密码:')
    if pwd =='8888':
        print('密码正确')
        break
    else:
        print('密码错误,请重新输入,你还可剩余输入密码次数:',2-item)


print('-----------while-------------------------')

a=0
while a<3:
    pwd = input('请输入你的密码:')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码错误,请重新输入,你还可剩余输入密码次数:', 2 - a)
    a+=1

print('-----多层循环中,breake值结束自己循环的当前循环------------------------------------------')
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            break
        print(j,end='\t')
    print()

5.5、continue

它的作用是立即跳出当前循环,进入下一循环

他只负责控制自己所在的循环,如果在多重循环中,他只负责结束自己循环的部分,不结束外层循环

""""输出1-50之间所有5的倍数"""

for item in range(1,51):
    if not item%5:  # 相当于if item%5==0
        print(item)

print('--------使用continue表示-----------------------')

for item in range(1,51):
    if item%5: # 相当于if item%5!=0
        continue
    print(item)

print('-----多层循环中,continue值结束自己循环的当前循环------------------------------------------')
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            continue
        print(j,end='\t')
    print()

5.6、else语句:

有三种搭配方式

1.和if搭配:和if搭配的时候,if语句或者else语句只执行其一即可

2.和while搭配:如果while语句执行完的时候,没有出现break,则执行else,如果出现break,则不执行else

3.和for搭配:和while搭配同理

for item in range(3):
    pwd=input('请输入密码:')
    if pwd=='8888':
        print('密码正确')
        break
   else:
        print('密码错误.')
else: #这个是和for对应的
    print('已经输入密码错误三次,请过90S之后再次尝试')


print('-------和while搭配-------------------')

a=0
while a<3:
    pwd = input('请输入密码:')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码错误.')
    a+=1
else:
    print('已经输入密码错误三次,请过90S之后再次尝试')

5.7、循环嵌套

这个模块有三个实例

'''输出一个三行四列的矩形'''

#在print函数里面,end参数表示的是输出完成之后该做什么,默认情况下,end='\n',如果要求不换行的话,可以设置end=''或者end='\t'

for item in range(3):
    for item1 in range(4):
        print('*',end='\t')
    print('')

'''输出一个直角三角形,最后一行是9个*'''

for i in range(1,10):
    for j in range(0,i):
        print('*', end='')
    print('')

for i in range(9):
    for j in range(1,i+1):
        if  j-i<=1:
            print('*', end='')
    print('')
    
for i in range(1,10):
    for j in range(1,10):
        if i>=j:
            print('*', end='')
    print('')

'''输出一个9*9乘法表'''

for i in range(9):
    for j in range(1,i+1):
        if  j-i<=1:
            print(i, '*', j, '=', i * j, end='\t')
    print('')
    
for i in range(1,10):
    for j in range(1,10):
        if i>=j:
            print(i, '*', j, '=', i * j, end='\t')
    print('')


for i in range(1,10):
    for j in range(0,i):
        print(i, '*', j+1, '=', i * (j+1), end='\t')
    print('')

六、列表

6.1、列表的初始化

• 为什么要使用列表?

列表就好比C语言中的数组,它可以在这个数组里面保存各种类型的数据,保存的数据更多,所以引入列表,来帮助变量只能保存一个数值的尴尬境地

lis=['hello','world',95,98.5]
print(lis)

在这个代码里面,list是列表名,保存的id值,然后这个id值可以指向保存里面三个数据的id值,三个数据的id值指向具体数值

• 列表的初始化:

有两种方法:
1.直接使用[],在[]里面写入列表

b=['hello','world',95,98.5]
print(b)

2.使用内置函数list(),在()里面加入[],创建列表,可以用在将range函数转换为列表

list2=list(['sad','sadsa'])
print(list2)

list3=list(range(100))
print(list3)

#list2=list(['sad','sadsa'],['sad','dsad'])          不能在里面创建多个列表的

• 列表的特点?

1.可以存储相同的元素

m=[98,98,98,'dsa']
print(m)

2.可以通过索引指定元素,从左到右的话,从0开始计数,从右到左的话,从-1开始计数,总之,列表中元素的个数等于从左到右的计数+从右到左的绝对值的和

m=['asdsa','sdadsa','qwewqe']
print(m[1],m[-2])           #会输出同一个值

3.可以存取任意数据类型的数据

6.2、获取列表指定元素的索引值

index()，获取列表指定元素的索引值,是通过list的index方法来获取的.

index方法使用有以下三个注意点:

1.index只会返回寻找到第一个的索引值,所以如果列表中有重复元素,index也只会返回第一个

list1=['hello','adasd','dsadsa','zxcxzc','hello']

print(list1.index('hello'))        #输出为0     #虽然list1列表中有两个hello值,但是只会返回第一个找到的索引值,所以输出为0

2.如果index找不到指定元素,会报错的

list3=['cx','dsa',9800]
print(list3.index('hello'))         #输出:ValueError: 'hello' is not in list,这个属于报错,会导致下面的代码无法正常执行

3.index方法可以指定寻找的序列,index(‘要寻找的值’,x,y),x表示开始寻找的序列,y表示结束寻找的序列

list4=['sadad','xzc','qewqe','yiuy']
print(list4.index('qewqe',0,3))               #输出结果为2

6.3、 获取列表中的单个元素

1.可以正向获取,也可以逆向获取,正向获取的时候,从0开始计数,逆向获取的时候,从-N开始计数

2.如果获取的索引值超过列表的范围,就会报错

li=['xcz','sadas','xzxz','wqqww']
print(li[1])                #输出第二个数据
print(li[-1])               #输出最后一个数据
#print(li[6])              超出列表的范围,所以报错

6.4、获取列表的多个元素

获取多个元素采用切片法，语法格式如下:

列表名[start:stop:step]

切片获取的列表为一个新的列表,因为他和旧的列表的id值是不相同的

lis=[0,1,2,3,4,5,6,7]
print('原列表',id(lis),lis)

lis1=lis[2:6:1]
print('切的片段',id(lis1),lis1)  #地址是不一样的

总共会有一下几种场景使用:

1.正常操作

list1=[0,10,20,30,40,50,60,70,80,90]

print(list1[0:7:1])     #会输出[0, 10, 20, 30, 40, 50, 60]

print(list1[0:7:3])     #输出[0, 30, 60]

2.省略起始值.

省略初始值时,会默认初始值为0

print(list1[:7:1])      #输出[0, 10, 20, 30, 40, 50, 60]

3.省略终止值

省略终止值时,会默认终止值为最后一个数值

print(list1[1::1])       #输出[10, 20, 30, 40, 50, 60, 70, 80, 90]

4.省略步长

省略步长时,默认步长为1

print(list1[1:7:])       #输出[10, 20, 30, 40, 50, 60]

5.当步长为负数时

切片的第一个元素默认是列表的最后一个元素

步长为负数时,可以理解为从起始值的位置开始减,一直减到终止值位置

print(list1[6:2:-1])       #输出[60, 50, 40, 30]

一般情况下,列表逆序输出的时候,都是采用步长为负数进行输出

print(list1[::-1])          #输出[90, 80, 70, 60, 50, 40, 30, 20, 10, 0]

6.5、判断指定元素在列表中是否存在、列表元素的遍历

• 判断指定元素在列表中是否存在
  in 或者 not in

lis=[1,213,5.5,'sagdja','adsasd']
print(1 in lis)
print(20 in lis)
print(22 not in lis)
print( 'sagdja' not in lis)

• 列表元素的遍历
  采用for in循环:

lis=[1,213,5.5,'sagdja','adsasd']
for item in lis:
    print(item)

6.6、 列表的添加操作

列表的添加元素有四种方法:

列表的添加操作不改变列表的id值,所以相当于没有新的列表产生

比较常用的是append,四种方法包括append,extend,insert以及切片法

• 1.append

将需要添加的元素填充到列表的末尾,只允许添加一个元素,如果这个元素是一个列表.会把这个元素当成一个列表,然后全部插入

lis=['zxZ','dwq','wqe','zxc','wr','cfwf']
lis.append(95)
print(lis)              #输出['zxZ', 'dwq', 'wqe', 'zxc', 'wr', 'cfwf', 95]

lis2=[1,2,3,4]
lis.append(lis2)
print(lis)              #输出['zxZ', 'dwq', 'wqe', 'zxc', 'wr', 'cfwf', 95, [1, 2, 3, 4]]

• 2.extend

可以在末尾添加多个元素,是append的补充,比如在下面的lis1里面插入lis2,不会把lis2整体插入,会把里面的元素取出来,然后插入

lis1=['zxZ','dwq','wqe','zxc','wr','cfwf']

lis2=[1,2,3,4]

lis1.extend(lis2)

print(lis1)                  #输出['zxZ', 'dwq', 'wqe', 'zxc', 'wr', 'cfwf', 1, 2, 3, 4]

• 3.insert

可以在列表中的任意位置插入元素,但是只能插入一个,语法格式如下

列表名.insert(索引值,插入的元素),表示在索引值-----前面----插入元素

lis1=['zxZ','dwq','wqe','zxc','wr','cfwf']

lis2=[1,2,3,4]
lis1.insert(1,lis2)
print(lis1)                 #输出结果['zxZ', [1, 2, 3, 4], 'dwq', 'wqe', 'zxc', 'wr', 'cfwf']

lis1.insert(0,98)
print(lis1)                 #在索引值前面插入字符   [98, 'zxZ', [1, 2, 3, 4], 'dwq', 'wqe', 'zxc', 'wr', 'cfwf']

• 4.片选插入

可以在列表的任意位置后面,插入多个元素,相当于切掉这个切片的元素值,改用新的元素代替

lis1=['zxZ','dwq','wqe','zxc','wr','cfwf']

lis2=[1,2,3,4]

lis1[1:4:]=lis2
print(lis1)                 #输出['zxZ', 1, 2, 3, 4, 'wr', 'cfwf']


lis1[1::]=[1,2]
print(lis1)                 #输出['zxZ', 1, 2]

6.7、列表中的删除操作

列表中的删除操作总共有五种方法,分别是remove,pop,切片,del,clear这五种，remove是根据这个元素的值来移除,而pop是以那个元素的索引值来移除

• 1.remove:用来移除列表中的某一个指定元素,会有三种情况

1.1移除这个元素不存在,这种情况会报错

'''lis=['sad','xzX','xzX','zxXZxxq']
lis.remove('qwe')               #输出:ValueError: list.remove(x): x not in list
print(lis)'''

1.2移除的这个元素在列表中有多个重复的,这种情况之会移除列表中第一个这个元素,不会移除所有的重复的

lis1=[1,5,6,8,9,7,5]
lis1.remove(5)
print(lis1)                     #输出[1, 6, 8, 9, 7, 5]

1.3正常移除

lis2=['xczc','dqdc.','24r2x','asda',98]
lis2.remove(98)
print(lis2)                     #输出['xczc', 'dqdc.', '24r2x', 'asda']

• 2.pop()

pop方法也会有三种情况

2.1索引值超出这个列表的范围

'''lis3=[1,2,3,5,7,9]
lis3.pop(8)
print(lis3)  '''                  #输出IndexError: pop index out of range''

2.2不知道索引值的话,会默认删除列表的最后一个元素

lis4=[2,5,9,7,'fds']
lis4.pop()
print(lis4)                     #输出[2, 5, 9, 7]

2.3正常移除

lis5=[5,9,'adasd','xZX','qwe']
lis5.pop(2)
print(lis5)                      #输出[5, 9, 'xZX', 'qwe']

• 3.切片删除

切片删除有两种情况,一种是把原列表的元素提取出来,组成一个新的列表,第二种情况是在原来的列表上面插入空的列表,就是用空的列表替换原来的列表

3.1

lis6=[5,9,9,7,2,3,8]
new_list=lis6[2:4]
print(new_list)                     #输出[9, 7]

3.2

lis7=[8,9,2,7,33,78,8]
lis7[2:4]=[]
print(lis7)                     #输出[8, 9, 33, 78, 8]

• 4.clear

指的是清空列表所有的元素,他就会变成一个空列表

lis8=[8,9,3,55,66,441.2,7]
lis8.clear()                    #语法格式如此
print(lis8)                     #输出[]

• 5.del

指的是直接删除这个列表变量,所以如果再打印这个变量的话,由于已经删除的关系,就会报错

'''lis9=[5,9651,25,456,879,4132,5641,7]
del lis9                        #语法格式如此
print(lis9)                     #报错NameError: name 'lis9' is not defined'''

6.8、列表元素的修改操作

对单个元素直接修改:

lis=[49,8,9,48,56,8,61,7]
print(lis)                  #输出[49, 8, 9, 48, 56, 8, 61, 7]
lis[5]=499
print(lis)                  #输出[49, 8, 9, 48, 56, 499, 61, 7]

2.切片修改:

lis1=[789,56,46,5,8,4,65,465,46,64] 
lis1[1:2]=['python','cxz','cxzcz']  #注意1:2 右边的2取不到
print(lis1)                 #输出[789, 'python', 'cxz', 'cxzcz', 46, 5, 8, 4, 65, 465, 46, 64]

6.9、对列表的排序操作

有两种操作方法:

1.使用列表自有的sort()方法

2.使用内置函数sorted()方法

!!!他俩之间的区别在于前者不会产生新的列表,而后者会产生新的列表!!!

• 1.使用列表自有的sort()方法

该方法默认是升序排列,可以通过设置reverse的值为True是的其变成降序排列

list1=[6,451,5,456,4546,8,8,98,12,777]
list1.sort()
print(list1)            #输出:[5, 6, 8, 8, 12, 98, 451, 456, 777, 4546]

list1.sort(reverse=True)
print(list1)            #输出[4546, 777, 456, 451, 98, 12, 8, 8, 6, 5]

• 2.使用内置函数sorted()方法

该方法默认是升序排列,可以通过设置reverse的值为True是的其变成降序排列

list2=[48,915,312,5,8,123,56,123]
list3=sorted(list2)
print((list3))          #输出[5, 8, 48, 56, 123, 123, 312, 915]

list4=sorted(list3,reverse=True)
print(list4)            #输出[915, 312, 123, 123, 56, 48, 8, 5]

6.9、列表生成式:生成列表的公式

语法格式如下

list=[要存储的列表元素 for i/item in range(a,b)]

range函数可以用以后其他的东西代替的,但是列表生成式可以固定下来的

li=[i for i in range(1,6)]
print(li)

print('-----------现在要求 生成一个含有2,4,6,8,10的列表-----')
li=[2*i for i in range(1,6)]
print(li)

m=list(range(1,10))
print(m)

七、字典

7.1、基础知识

可变序列：目前包括字典、列表

不可变序列：目前包括整数，字符串

区别在于可变序列可以进行增、删、查、改操作，而不可变序列不可以进行

7.2、 字典的组成及原理

字典是由键值对组成的，字典是无序的排列方式，他不是根据你输入键的前后顺序来存储他，而是根据键的哈希值来存储

也是由于这个原因，字典的键必须是一个不可变序列，而且键不可以重复

语法格式如此：字典名={键：值，键：值，…}

• 字典的实现原理：

他是先由哈希函数计算键从而得到不同键的索引,然后根据键的索引排序键，键中保存的是值的地址，从而达到引用键而找到值的效果

• 字典特点：

1.字典中键值对是一一对应的，其中，键是不可以重复的，一旦重复会出现值覆盖，而值是可以重复的

2.字典中的键值对是无序的（不能在指定的位置插入一个键值对）

3.字典是一种用空间换时间的数据结构

4.字典的键必须是不可变对象

7.3、字典的创建方式

字典的创建方式总共有两种：

• 1.通过{}创建字典

score={'tom':85,'jack':92,'sam':'pass'}
print(score)                        #输出{'tom': 85, 'jack': 92, 'sam': 'pass'}

print(type(score))                  #输出<class 'dict'>

• 2.通过内置函数dict()创建字典

在()里面写入键值对，与{}不同的是，这种创建方式为键=值，而不是键：值，这点需要注意

student=dict(tom=85,jack=92,sam='pass')
print(student)                      #输出{'tom': 85, 'jack': 92, 'sam': 'pass'}
print(type(student))

• 3.创建一个空列表

empty={}                            
print(empty)		#输出{}

empty1=dict()						
print(empty1)		#输出{}

7.4、字典元素的获取、key的判断

字典元素的获取有两种方法：

• 1.使用 [ ] 获取，[ ] 里面是键值

score={'tom':85,'jack':92,'sam':'pass'}
print(score)
print(score['tom'])             #输出58

#print(score['alice'])               #如果查找不到，就会报错：KeyError: 'alice'

• 2.使用get()方法获取

score={'tom':58,'linda':62,'jack':98}
print(score.get('tom'))             #输出58

print(score.get('alice')) #如果查找不到就会输出：None，这个none是可以代替的，在键后面加入替代的值，找不到就会输出替代的值
print(score.get('alice',56))        #输出56，如果查找不到就会默认输出键后面的值

• key的判断

score={'tom':58,'linda':62,'jack':98}
print(score)
print('张三' in score)
print('张三' not in score)

7.5、字典元素的增删改操作

• 1.字典元素的修改

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
print(dict)             #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}

dict['tom']=100
print(dict)             #输出{'tom': 100, 'jack': 59, 'marry': 53, '刘桂香': 77}

• 2.字典元素的删除：

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
print(dict)             #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}

del dict['tom']             #删除会删除整个键值对
print(dict)             #输出{'jack': 59, 'marry': 53, '刘桂香': 77}

• 3.字典元素的增加

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
print(dict)

dict['alice']=5666
print(dict)                 #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77, 'alice': 5666}

• 4 字典元素的清空

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
print(dict)                 #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}

dict.clear()
print(dict)                 #输出{}

7.6、获取字典视图

实际上就是获取字典里面所有的键，所有的值，以及所有的键值对

这三种东西的获取方法各有不同，虽然方法各不一样，但是操作原理，用法都是一样的

• 1.获取所有的键

keys()函数

score={'tom':58,'linda':62,'jack':98}

a=score.keys()
print(a)            #输出dict_keys(['tom', 'linda', 'jack'])

#可以将输出的键进行列表化，获得键的列表
print(list(a))      #输出['tom', 'linda', 'jack']

• 2.获取所有的值

values()函数

score={'tom':58,'linda':62,'jack':98}
b=score.values()
print(b)                # 输出dict_values([58, 62, 98])
print(list(b))          #输出[58, 62, 98]

• 3.获取所有的键值对

items()函数

score={'tom':58,'linda':62,'jack':98}

print(score.items())        #输出dict_items([('tom', 58), ('linda', 62), ('jack', 98)])
print(list(score.items()))          #输出[('tom', 58), ('linda', 62), ('jack', 98)]
#转换之后的列表元素是由元组组成的

7.7、字典元素的遍历

使用for in循环进行遍历

score={'tom':58,'linda':62,'jack':98}

for i in score:             #这里的i表示的是字典里的键，如果要获取字典的值，就需要使用[]获取或者get函数获取
    print(i,score[i])
    print(i,score.get(i))

7.8、字典生成式

实际上和列表生成式差不太多，多使用了一个内置函数zip，而且由于字典是由键值对组成的，所以需要两个可迭代对象

zip函数组成字典生成式里面，如果键的个数和值得个数不相同时，以小的为准

#要求：将item的每个元素做键，将prices的元素对应做值
items=['books','fruits','papers']
prices=[98,56,233]

a={items:prices for items,prices in zip(items,prices)}
print(a)

a={i:j for i,j in zip(items,prices)} #键名、值名可以换
print(a)

prices1=[978,5,5,6451,1]       #当键和值的个数不一样的时候，以短的为准

b={m:n for m,n in zip(items,prices1)}
print(b)