1python的优点：语法简单，工具包丰富：数据处理简单。

2Java和python的区别：python没有编译过程，输入即得到，语法简单，书写简单，支持广泛的应用程序开发。

3pycharm 安装叠加python官网的python解释器

python中的输出函数

直接使用的函数

输出内容：数字，字符串，含有运算符的表达式。

输出位置：显示器，文件

输出形式：换行和不换行两种

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
print(520)
print(99.5)
print('hello world')
print("hello world")


#含有运算符的表达式，直接进行运算输出结果
print(3+1)
#以上均输出到控制台上

#将数据输出到文件中   注意点，1.所指定的盘符存在  2.使用file=“变量”
fp=open('D:/text.txt','a+')#如果文件不存在就创建，存在就在文件内容的后面继续追加
print('helllo world',file=fp)
fp.close()

#不进行换行输出（输出内容不在一行之中）
print('hello','world','python')

转译字符

定义：反斜杠加想要实现转义功能的首字母

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#转义字符
print('hello\nworld')   #\+转义字符的首字母，   n--》newline的首字母表示换行
print('hello\tworld')
print('helloooo\tworld')#\t代表四个单位格，\t就是刷新制表位，就是将制表位刷新
print('hello\rworld')#回车，hello会消失，回车就是本行回车，就是world对hello进行覆盖
print('hello\bworld')#\b是退一个格，将o退没了。


print('http:\\\\.baidu.com')#一个斜杠是功能性的斜杠
print('老师说:\'大家好\'')#斜杠加引号才输出引号，双引号同理


#原字符，不希望字符串中的转义字符起作用，即使用原字符，就是在字符串之前加r或R
#最后一个字符不能是反斜杠。 
print(r'hello\nworld') 
print(r'hello\nworld\\')

七十二变

二进制与字符编码

0和1表示两种状态，要表现更多状态只需要添加位置。

8位bit，叫做一个字节（1byte）8个位置可以表示256种状态–>产生了ascii表–>可以通过电脑计算器的程序员模式得到具体数字对应的二进制数字。

ASCII码表

GB2312可以表示简体中文，GBK不光可以表示简体中文还可以表示繁体中文，GB18030可以表示少数民族的文字（每个字符可以用多个字节表示）–》unicode是统一了中国和国际的所有表示字符（）–》utf-8中国的字符用三个字节表示，外国用asci表。

1
2
print(chr(0b100111001011000))
print(ord('乘'))

不论中文英文在计算机里都是字符的形式存在

1024byte=1kb

1024kb=1mb

1024mb=1gb

1024gb=1tb

python中的标识符和保留字

保留字：在我们对对象命名时不能使用保留字。

yyh的保留字：[‘False’, ‘None’, ‘True’, ‘peg_parser‘, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

查找保留字的代码

1
2
import keyword
print(keyword.kwlist)

标识符：对变量，函数类，模块和其他对象起的名字就叫标识符。

规则：可以使用字母数字下划线；不能使用数字开头；不能是保留字；大小写要注意。

变量的定义和使用

变量：其值是可以改变的量，内存中一个带标签的盒子。

name=‘玛丽亚’，这里的name属于标识符，要注意其使用的格式和方式。

变量由三部分组成：

  • 标识：表示对象存储的内存地址，使用内置函数id（obj）获取
  • 类型：表示的是对象的数据类型，通过内置函数type（obj）获取
  • 值：表示对象存储的具体数据，使用print（obj）可以将值进行打印输出，
1
2
3
4
5
6
name='玛丽亚'
print('name')
print('标识',id(name))
print('类型',type(name))
print('值',name)
#name里面存储的是变量的id

当多次赋值后，变量名会指向新的空间。name由玛丽亚的盒子指向yyh的盒子，也就是指向了新的空间。

1
2
3
4
name='玛丽亚'
print(name)
name='yyh'
print(name)

数据类型

常用的数据类型：

整数类型–》int–》98

浮点类型–》float–》3.14159

布尔类型–》bool–》只输出两个值true/false

字符串类型–》str–》只要加入单引号，双引号，三引号均为字符串类型。

整数类型

可以表示正数，负数，0

整数的不同进制的表示：

1
2
3
4
5
6
7
8
9
10
11
12
13
#整数类型
#可以表示正数负数零
n1=90
n2=-76
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#整数可以表示为二进制，十进制，十六进制，八进制
print('十进制',118)
print('二进制',0b1011011)
print('八进制',0o765321)
print('十六进制',0x1EAF)
浮点类型

浮点数是由整数部分和小数部分组成

浮点数存储具有不准确性

1
2
3
4
5
6
7
8
9
10
11
a=3.14159
print(a,type(a))
n1=1.1
n2=2.2
n3=2.1
print(n1+n2)#计算机是用二进制存储的，存储具有误差.个别情况会产生误差，某些不会有。
print(n1+n3)


from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))#解决的办法，使用特定的函数
布尔类型（boolean）

  • 用来表示真假的词

  • true表示真，false表示假

  • 布尔值可以转换为整数：true–>;false–>0

1
2
3
4
5
6
7
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))
#布尔值可以转成整数计算
print(f1+1)  #2  1+1的结果为2    true表示1
print(f2+1)  #1   0+！的结果为1  false表示的是 0
字符串类型

不可变的字符序列

可以使用单引号，双引号，三引号，‘’‘ ’‘’或“”“ ”“”来定义

单引号，双引号定义的字符串必须在一行

三引号定义的字符串可以分布在连续的多行

1
2
3
4
5
6
7
8
9
10
11
str1='人生苦短，我用python'
str2="人生苦短，我用python"
str3="""人生苦短，
我用python"""
str4='''人生苦短，
我用python'''
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))
#单引号，双引号不能换行，但三引号就可以输出换行

数据类型转换

![img](file:///C:\Users\yyh\Documents\Tencent Files\2050157259\Image\C2C\WZPK$AJTC4LWERDZ7ALJR.png)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
name='张三'
age=20
print(type(name),type(age))#说明name和age的数据类型不相同
#print('我叫'+name+'今年，'+age+'岁')#这里是错误示范
print('我叫'+name+',今年'+str(age)+'岁')#加号是连接符，将str类型和int类型时报错，解决方式为类型转换


print('------------str()将其他类型转换成str类型--------')
a=10
b=198.8
c=False
print(type(a),type(b),type(c))
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))


print('--------------int()将其他类型转换成int类型-------------')
s1='128'
f1=98.7
s2='76.74'
ff=True
s3='hello'
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1)))  #将str转换成int类型，字符串为数字串
print(int(f1),type(f1))   #float转换成int类型，截取整数部分舍掉小数部分
#print(int(s2),type(s2))   #将str转换成int类型，报错，因为字符串为小数串。
print(int(ff),type(int(ff)))
#print(int(s3),type(int(s3)))#将str转换成int类型必须是数字串（整数），非数字串不允许转换，报错。



print('---------------float()函数，将其他数据类型转换成flaot类型-------------')
s1='128.98'
s2='76'
ff=True
s3='hello'
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff)))
#print(float(s3),type(float(s3)))#字符串中如果是非数字串，则不能转换
print(float(i),type(float(i)))

python中的注释

在代码中对代码的功能进行解释性说明的标注性文字，提高代码的可读性。

通常包括：1单行注释，以‘#‘开头直到换行结束。2多行注释，并没有单独的多行注释，将一对三引号之间的代码称为多行注释。3中文编码的声明注释

在代码的最开始加 #coding：utf-8或 #coding：gbk

1
2
3
#coding:utf-8
# 编译者：尹英豪
# 开发时间：2021/5/14 17:28

算你赢

python的输入函数input（）

input ()函数是用来接收用户输入的，输入值的类型为str，值的存储为，使用=对输入的值进行存储。

present=input(‘大圣想要什么礼物？’)

1
2
3
4
5
6
7
a=input('请输入一个加数：')
b=input('请输入另一个加数：')
#a=int(input('请输入一个加数：'))
#b=int(input('请输入另一个加数：'))
print(type(a),type(b))
print(a+b)  #并没有进行a+b的运算,只起到连接作用
print(int(a)+int(b))

常用运算符

包括：算术运算符，赋值运算符，比较运算符，布尔运算符，位运算符

算术运算符

包括：标准算数运算符（+，-，，/,//），取余标准运算符%，幂运算符*

1
2
3
4
5
6
7
print(1+1)#执行加法运算
print(1-1)#减法运算
print(2*4)#乘法运算
print(1/2)#除法运算
print(11//2)#整除运算
print(11%2)#取余运算
print(2**3)#幂运算

一正一负的整除和取余情况

1
2
3
4
5
print(9//4)
print(-9//-4)
print(9//-4)#一正一负向下取整
print(9%-4)#公式：被除数-除数*商
print(-9%4)

赋值运算符

执行顺序从右到左

支持链式赋值，支持参数赋值，支持系列解包赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
i=3+4
print(i)
a=b=c=20#链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('--------------支持参数赋值----------------')
a=20
a+=30#a=a+30
print(a)
a-=10#a=a-10
print(a)
a*=2#a=a*2
print(a)
print(type(a))
a/=3
print(a)
a//=2
print(a)
print(type(a))
a%=3
print(a)
print('-----------支持系列解包赋值-------------')
a,b,c=20,30,40#有三个对象，对应三个存储位置
print(a,b,c)
print('----------交换两个变量的值----------------')
a,b=20,30
print('交换之前',a,b)
#交换
a,b=b,a
print('交换之后',a,b)
比较运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#比较运算符
a,b=10,20
print('a>b吗',a>b)#比较运算符的结果是布尔类型
print('a<b吗',a<b)
print('a<=b吗',a<=b)
print('a>=b吗',a>=b)
print('a==b吗',a==b)
print('a!=b吗',a!=b)

'''一个=是赋值运算符，两个==称为比较运算符
一个变量由三部分组成：标识，类型，值
==比较的是值还是标识呢 ？==比较的是两个变量的值
比较对象的标识使用  is
'''
a=10
b=10
print(a==b)  #说明a与b的值相等
print(id(a))
print(a is b)  #说明a与b的id标识相等
#以下代码未学习
lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2)  #value-->true
print(lst1 is lst2)#id
print(id(lst1))
print(id(lst2))
print(a is not b)#false,  a的id和b的id是不相等的是错误的
print(lst1 is not lst2)  #true   lst1的idlst2的id是不相等的是正确的
布尔运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#布尔运算符
a,b=1,2
print('--------------and并且----------------')
print(a==1 and b==2)#ture   true and true
print(a==1 and b<2)   #false  true and  false
print(a!=1 and b==2)  #false false and true
print(a!=1 and b!=2)  #false  false and false


print('-------------or或者---------------')
print(a==1  or  b==2)
print(a==1 or b<2)
print(a!=1 or b==2)
print(a!=1 or b!=2)

print('---------not---------------')
f1=True
f2=False
print(not f1)
print(not f2)


print('--------------in 和not in-----------------')
s='hello world'
print('w' in s)
print('k' in s)
print('w'  not in s)
print('k' not in s)
位运算符

将数据转成二进制进行运算

按位与：同1为1，其余为0

按位或：同0为0，其余为1

1
2
print(4&8)#按位与，同为1时结果为1
print(4|8)#按位或，同为0时结果才是0

左移位运算符：二进制下全体向左移位，超出位高位溢出，低位补零。移一位相当于乘2。

右移位运算符：二进制全体右移，高位补零，低位截断。

1
2
3
4
print(4<<1)#向左移动一个位置，相当于乘以2
print(4<<2)#向左移动两位
print(4>>1)#向右移动一位
print(4>>2)#向右移动两位

python中的运算符优先级

算术运算符（先乘除后加减，有幂次先算幂次）–>位运算（左右移位，与，或）–>比较运算符–>布尔运算–>赋值运算

由括号先算括号内的内容

往哪走（程序的流程控制）

程序的组织结构

任何算法都可以由顺序结构，选择结构，循环结构构成。

顺序结构

程序从上到下顺序执行代码，中间没有判断和跳转，直到程序结束。

1
2
3
4
5
6
7
'''把大象装冰箱一共分几步'''
print('-----------程序开始---------------')
print('1.把冰箱门打卡')
print('2.把大象放到冰箱里')
print('3.把冰箱门关上')
print('---------程序结束----------')
#整个过程没有进行判断跳转，所以以上程序是顺序结构

对象的布尔值

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

获取对象的布尔值：使用内置函数bool（）

以下对象均为false：

false 数值 none 空字符串 空列表 空元组 空字典 空集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#测试对象的布尔值
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()))#空元组
print(bool({}))#空字典
print(bool(dict()))#空字典
print(bool(set()))#空集合
print('------------------其他对象的布尔值均为True---------------------------')
print(bool(18))
print(bool('hello world'))
print(bool(True))

选择结构

单分支结构

中文语义：如果，，，，就，，，，，。

语法结构：if 条件表达式：条件执行体

1
2
3
4
5
6
7
money=1000  #余额
s=int(input('请输入取款金额'))  #取款金额
#判断余额是否充足
if money>=s:
    money=money-s
    print('取款成功，余额为：',money)

双分支结构

中文语义：如果，，，，，，，不满足，，，，，，，，，就，，，，，，，，，。

语法结构：

if条件表达式：

条件执行体1

else ：

条件执行体2

1
2
3
4
5
6
7
8
9
10
#双分支结构：if    else    二选一执行
'''从键盘录入一个整数，编写程序让计算机判断是基数还是偶数'''
num=int(input('请输入一个整数'))

#条件判断
if num%2 == 0:
    print('这个数值是偶数')
else:
    print('这个数值是基数')

多分支结构

if 条件表达式1：

条件执行体1

elif 条件表达式2：

条件表达式2

elif 条件表达式N：

条件执行体N

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'''多分支结构，多选一执行
从键盘录入一个整数  成绩
90-100   A
80-89   B
70-79  C
60-69   D
0-59   E
小于0大于100为非法数据
'''
score=int(input('请录入一个成绩：'))
#判断
if score>=90 and score<=100:
    print('A')
elif score>=80 and score<=89:
    print('B')
elif 70<=score<=79:
    print('C')
elif score>=60 and score<=69:
    print('D')
elif score>=0 and score<=59:
    print('E')
else:
    print('对不起，成绩有限，不在成绩的有效范围')
嵌套if

语法结构：

if条件表达式1：

if内层条件表达式：

​ 内存条件执行体1

else：

​ 内存条件执行体2

else：

​ 条件执行体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'''
会员  》=200 8折
    》=100  9折
    《100   不打折
非会员   》=200  9.5折
    不打折
'''
answer=input('您是否为会员？y/n')
money=float(input('请输入你的购物金额'))
#外层判断是否为会员
if answer=='y':#会员
  if money>=200:
      print('打8折，付款金额为',money*0.8)
  elif money>=100:
      print('打9折，付款金额为',money*0.9)
  else:
      print('不打折，付款金额为',money)
else:#非会员
  if money>=200:
      print('打9.5折，付款金额为',money*0.95)
  else:
      print('不打折付款金额为',money)

条件表达式

if else 的简写

语法结构：

x if 判断条件 else y

1
2
3
4
5
6
7
8
9
10
11
12
13
#从键盘录入两个整数，比较两个整数的大小
num_a=int(input('请输入一个整数'))
num_b=int(input('请输入另一个整数'))
#比较大小
'''if num_a>=num_b:
    print(num_a,'大于等于',num_b)
else:
    print(num_a,'小于等于',num_b)
'''
print('使用条件表达式比较')
print(str(num_a)+'大于等于'+str(num_b)if num_a>=num_b else str(num_a)+'小于等于'+str(num_b))
#条件判断的结果为true会执行if前的语句，如果条件判断结果为false，执else后面的语句

pass语句

pass语句:语句什么都不做，只是一个占位符，用在语法上需要语句的地方

什么时候使用：先搭建语法结构，还没想好代码怎么写的时候

哪些语句一起使用：

if语句的条件执行体；for-in语句的循环体；定义函数时的函数体

1
2
3
4
5
6
answer=input('您是会员吗？y/n')
#判断是否是会员
if  answer=='y':
   pass
else:
    pass#保证语法不报错

对象的布尔值，可以直接把对象放到条件表达式里做判断。

1
2
3
4
5
age=int(input('请输入您的年龄：'))
if age:
    print(age)
else:
    print('年龄为',age)

转圈圈

range（）函数的使用

是一个内置函数：直接可以使用，不需要加任何前缀

用于生成一个整数序列

创建range对象的三种方式

range函数存储内存只有三个数，表达个数可能不同，但是存储内存相同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#range（）函数的三种创建方式
'''第一种创建方式，只有一个参数（小括号里只给了一个数）'''
r=range(10)#并未告诉从几开始，默认从0开始，并未规定步长为多少，默认步长为1。
print(r)#结果是一个迭代器对象，看不到range对象的具体数据
print(list(r))#用于查看range中的整数序列     -->list是列表的意思
'''第二种创建方式，给了两个参数（小括号中给了两个数）第一个表示start，第二个表示stop'''
r=range(1,10)#指定了起始值，从一开始，到十结束(不包含十)，默认步长为1
print(list(r))
'''第三种表达方式，给了三个参数（小括号里面给了三个数）start，stop，step'''
r=range(1,10,2)
print(list(r))
'''判断指定指数在数列中是否存在'''
print(10 in r)#False,10不在当前的r这个整数序列中
print(9 in r)
print(10 not in r)
print(9 not in r)

循环结构

语法结构：

1while 2 for in

while 条件表达式：

​ 条件执行体（循环体）

选择结构的if和循环结构while的区别

if是判断一次，条件为true执行一行；while是判断N+1次，条件为true执行N次。

1
2
3
4
5
a=1
#判断条件表达式
while a<10:#执行条件执行体
    print(a)
    a += 1
四步循环法

初始化变量；条件判断；条件执行体；改变变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'''
4步循环法
1初始化变量
2条件判断
3条件执行体（循环体）
4改变变量
总结：初始化的变量和条件判断的变量和改变的变量为同一个
'''
'''初始化变量为0'''
a=0
sum=0#用于存储累加和
'''条件判断'''
while a<5:
    '''条件执行体（循环体）'''
    sum+=a
    '''改变变量'''
    a+=1
print('和为',sum)

练习，计算一到一百之间的偶数和。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'''计算一到一百之间的偶数和'''
'''初始化变量'''
print(bool(0))
sum=0#用于存储偶数和
a=1
'''条件判断'''
while a<=100:
    '''条件执行体（求和）'''
    #条件判断是否为偶数
    if a%2==0:#a%2(输出的是奇数和)或 not bool（a%2）(输出的是偶数和)
        sum+=a
    '''改变变量'''
    a+=1
print('1到100之间的偶数和',sum)

for in循环

in表示从字符串或序列等中依次取值，又称遍历

for in便利的对象必须是迭代对象

for in的语法结构：for 自定义的变量 in 可迭代对象:循环体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
for item in 'python':
    print(item)

#range()产生一个整数序列---》也是一个可迭代对象
for i in range(10):
    print(i)

#如果在循环体中不需要使用自定义变量，可将自定义变量写为"_”
for _ in range(5):
    print('人生苦短')

print('使用for循环，计算1到100之间的偶数和')
sum=0
for item in range(1,101):
    if item%2==0:
        sum+=item
print('1到100之间的偶数和为：',sum)
break
1
2
3
4
5
6
7
8
9
'''从键盘录入密码，最多录入三次，如果正常就结束循环'''
for item in range(3):
    pwd=input('请输入密码')
    if pwd=='8888':
      print('密码正确')
      break
    else:
      print('不正确')

continue
1
2
3
4
5
6
7
8
9
10
11
'''要求输出1到50之间5的倍数'''
for item in range(1,51):
     if item%5==0:
         print(item)


print('-------------使用continue------------------')
for item in range(1,51):
    if item%5!=0:
        continue
    print(item)
流程控制语句break和continue的二重循环中的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
'''流程控制语句break和continue的二重循环中的使用'''
for i in range(5):#外层循环要执行五次
    for j in range(1,11):
        if j%2==0:
            break
        print(j)

for i in range(5):#外层循环要执行五次
    for j in range(1,11):
        if j%2==0:
            continue
        print(j,end='\t')
    print()
else在while和for语句中的作用
1
2
3
4
5
6
7
8
9
10
11
12
a=0
while a<3:
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    '''改变变量'''
    a+=1
else:
    print('对不起，三次密码不正确')
1
2
3
4
5
6
7
8
9
for item in range(3):
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起三次密码输入均不正确')
循环的嵌套
1
2
3
4
5
6
7
8
9
10
11
12
'''输出一个三行四列的矩阵'''
for i in range(1,4):  #行表，执行三次，一次一行
    for j in range(1,5):
        print('*',end='\t')  #不换行输出
    print()#打行

'''输出一个99乘法表'''
for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='\t')
    print()

一字排开

变量可以存储一个元素，而列表是一个大容器可以存储多个元素，程序方便对这些数据做整体操作。

列表相当于其他语言的数组

1
2
3
4
5
a=10  #变量存储的是一个变量的引用
lst=['hello','world',98]
print(id(lst))
print(type(lst))
print(lst)