语言元素

指令和程序

计算机的硬件系统通常由五大部件构成，包括：运算器、控制器、存储器、输入设备和输出设备。其中，运算器和控制器放在一起就是我们通常所说的中央处理器，它的功能是执行各种运算和控制指令以及处理计算机软件中的数据。我们通常所说的程序实际上就是指令的集合，我们程序就是将一系列的指令按照某种方式组织到一起，然后通过这些指令去控制计算机做我们想让它做的事情。今天我们大多数时候使用的计算机，虽然它们的元器件做工越来越精密，处理能力越来越强大，但究其本质来说仍然属于“冯·诺依曼结构”的计算机。“冯·诺依曼结构”有两个关键点，一是指出要将存储设备与中央处理器分开，二是提出了将数据以二进制方式编码。二进制是一种“逢二进一”的计数法，跟我们人类使用的“逢十进一”的计数法没有实质性的区别，人类因为有十根手指所以使用了十进制（因为在数数时十根手指用完之后就只能进位了，当然凡事都有例外，玛雅人可能是因为长年光着脚的原因把脚趾头也算上了，于是他们使用了二十进制的计数法，在这种计数法的指导下玛雅人的历法就与我们平常使用的历法不一样，而按照玛雅人的历法，2012年是上一个所谓的“太阳纪”的最后一年，而2013年则是新的“太阳纪”的开始，后来这件事情被以讹传讹的方式误传为”2012年是玛雅人预言的世界末日“这种荒诞的说法，今天我们可以大胆的猜测，玛雅文明之所以发展缓慢估计也与使用了二十进制有关）。对于计算机来说，二进制在物理器件上来说是最容易实现的（高电压表示1，低电压表示0），于是在“冯·诺依曼结构”的计算机都使用了二进制。虽然我们并不需要每个程序员都能够使用二进制的思维方式来工作，但是了解二进制以及它与我们生活中的十进制之间的转换关系，以及二进制与八进制和十六进制的转换关系还是有必要的。如果你对这一点不熟悉，可以自行使用维基百科或者百度百科科普一下。

变量和类型

在程序设计中，变量是一种存储数据的载体。计算机中的变量是实际存在的数据或者说是存储器中存储数据的一块内存空间，变量的值可以被读取和修改，这是所有计算和控制的基础。计算机能处理的数据有很多种类型，除了数值之外还可以处理文本、图形、音频、视频等各种各样的数据，那么不同的数据就需要定义不同的存储类型。Python中的数据类型很多，而且也允许我们自定义新的数据类型（这一点在后面会讲到），我们先介绍几种常用的数据类型。

  • 整型：Python中可以处理任意大小的整数（Python 2.x中有int和long两种类型的整数，但这种区分对Python来说意义不大，因此在Python 3.x中整数只有int这一种了），而且支持二进制（如0b100，换算成十进制是4）、八进制（如0o100，换算成十进制是64）、十进制（100）和十六进制（0x100，换算成十进制是256）的表示法。
  • 浮点型：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，浮点数除了数学写法（如123.456）之外还支持科学计数法（如1.23456e2）。
  • 字符串型：字符串是以单引号或双引号括起来的任意文本，比如'hello'和"hello",字符串还有原始字符串表示法、字节字符串表示法、Unicode字符串表示法，而且可以书写成多行的形式（用三个单引号或三个双引号开头，三个单引号或三个双引号结尾）。
  • 布尔型：布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来（例如3 < 5会产生布尔值True，而2 == 1会产生布尔值False）。
  • 复数型：形如3+5j，跟数学上的复数表示一样，唯一不同的是虚部的i换成了j。实际上，这个类型并不常用，大家了解一下就可以了。

变量命名

对于每个变量我们需要给它取一个名字，就如同我们每个人都有属于自己的响亮的名字一样。在Python中，变量命名需要遵循以下这些必须遵守硬性规则和强烈建议遵守的非硬性规则。

  • 硬性规则：
    • 变量名由字母（广义的Unicode字符，不包括特殊字符）、数字和下划线构成，数字不能开头。
    • 大小写敏感（大写的a和小写的A是两个不同的变量）。
    • 不要跟关键字（有特殊含义的单词，后面会讲到）和系统保留字（如函数、模块等的名字）冲突。
  • PEP 8要求：
    • 用小写字母拼写，多个单词用下划线连接。
    • 受保护的实例属性用单个下划线开头
    • 私有的实例属性用两个下划线开头

变量的使用

下面通过几个例子来说明变量的类型和变量使用。

1
2
3
4
5
6
7
8
9
"""
使用变量保存数据并进行加减乘除运算
"""
a = 321
b = 12
print(a + b)    # 333
print(a - b)    # 309
print(a * b)    # 3852
print(a / b)    # 26.75

在Python中可以使用type函数对变量的类型进行检查。程序设计中函数的概念跟数学上函数的概念是一致的，数学上的函数相信大家并不陌生，它包括了函数名、自变量和因变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
"""
使用type()检查变量的类型
"""
a = 100
b = 12.345
c = 1 + 5j
d = 'hello, world'
e = True
print(type(a))    # <class 'int'>
print(type(b))    # <class 'float'>
print(type(c))    # <class 'complex'>
print(type(d))    # <class 'str'>
print(type(e))    # <class 'bool'>

可以使用Python中内置的函数对变量类型进行转换。

  • int()：将一个数值或字符串转换成整数，可以指定进制。
  • float()：将一个字符串转换成浮点数。
  • str()：将指定的对象转换成字符串形式，可以指定编码。
  • chr()：将整数转换成该编码对应的字符串（一个字符）。
  • ord()：将字符串（一个字符）转换成对应的编码（整数）

下面的代码通过键盘输入两个整数来实现对两个整数的算术运算。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""
使用input()函数获取键盘输入(字符串)
使用int()函数将输入的字符串转换成整数
使用print()函数输出带占位符的字符串
"""
a = int(input('a = '))
b = int(input('b = '))
print('%d + %d = %d' % (a, b, a + b))
print('%d - %d = %d' % (a, b, a - b))
print('%d * %d = %d' % (a, b, a * b))
print('%d / %d = %f' % (a, b, a / b))
print('%d // %d = %d' % (a, b, a // b))
print('%d %% %d = %d' % (a, b, a % b))
print('%d ** %d = %d' % (a, b, a ** b))

说明：上面的print函数中输出的字符串使用了占位符语法，其中%d是整数的占位符，%f是小数的占位符，%%表示百分号（因为百分号代表了占位符，所以带占位符的字符串中要表示百分号必须写成%%），字符串之后的%后面跟的变量值会替换掉占位符然后输出到终端中，运行上面的程序，看看程序执行结果就明白啦。

运算符 描述
[] [:] 下标，切片
** 指数
~ + - 按位取反, 正负号
* / % // 乘，除，模，整除
+ - 加，减
>> << 右移，左移
& 按位与
^ `\ ` 按位异或，按位或
<= < > >= 小于等于，小于，大于，大于等于
== != == !=
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符
= += -= *= /= %= //= **= &= ` =`^= >>= <<= 复合）赋值运算符

说明： 在实际开发中，如果搞不清楚运算符的优先级，可以使用括号来确保运算的执行顺序。

打印字符

1
2
3
4
5
6
7
8
9
print('nihao') 
运算使用 print(198776543 + 2999999)将数据输出到文件中 注意！

1.所指定的盘符必须存在， 

2.使用file= fpfp = open('D:/text.txt', 'a+')如果文件不存在，就创建，如果有，就在文件里面继续追加 

3.print('nihao', file=fp)fp表示输入到上面一行的地址中 没有file，打印的内容就无法在新建的文本中显
close()关闭

转义字符

1
2
3
4
5
6
7
8
9
 print('hello\nnihao')#\  +转义字符的首字母   n-->newline的首字母表示换行  

 print('hello\tnihao')#\  +转义字符的首字母   t-->的首字母表示空出4个字符位 

 print('hello\rnihao')#\  +转义字符的首字母   r-->的首字母表示执行将前一个字符覆盖的字符 

print('hello\bnihao')#\  +转义字符的首字母   b-->的首字母表示退一格 

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

python中的保留字和标识符

1
2
3
4
5
6
7
8
 import keyword 

 print( keyword.kwlist)#['False', 'None', 
'True', 'and', 'as', 'assert', '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
3
print(chr(0b100111001011000)) 

 print(ord('乘'))

变量

1
2
3
4
5
6
7
8
9
name='天空北慕' 

print(name) 

print('标识',id(name)) 

print('类型',type(name)) 

print('值',name)

数据类型

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# 天空北慕·
# 开发时间：2022/11/20 21:45
#整数
n1=90
n2=-77
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
print('十进制',118)

#  浮点数
a=3.1415926
print(a,type(a))
n5=1.1
n22=2.2
print(n5+n22)
from decimal import  Decimal
print(Decimal('1.1')+Decimal('2.2'))
#布尔数据类型
#用来表示真或者假的值，布尔值在python中可以转成整数
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))
#布尔值可以转成整数计算
print(f1+1)  #1+1=2
print((f2+1))  #0+1=1
#字符串类型
#字符串又被称为不可变的字符序列
#可以使用单'双''引号""三引号''' '''来定义
#单引号和双引号的定义字符串必须在一行
#三引号的字符串可以分布在连续的多行
q1='认识你很幸运'
q2="认识你很幸运"
q3="""认识你很幸运"""
q4="""认识你很幸运
见到你也是"""
print(q1)
print(q2)
print(q3)
print(q4)
print(q1)
print(q2)
print(q3)
print(type(q1),type(q2),type(q3),type(q4))
#数据类型转换
wo='张三'
nianling=30
print(type(wo),type(nianling))#数据类型不同，
#print('我叫'+wo+'今年，'+strnianling+'岁了')#此时是报错的
print('我叫'+wo+'今年，'+str(nianling)+'岁了')#解决方案，将int类型通过str()函数int类型转换成为ser类型的
w1=10
w2=10.2
w3=False
print(type(w1),type(w2),type(w3))#<class 'int'> <class 'float'> <class 'bool'>
print(str(w1),str(w2),str(w3),type(str(w1)),type(str(w2)),type(str(w3)))
print('w1','w2','w3',type(str(w1)),type(str(w2)),type(str(w3)))#可以用引号转，
#10 10.2 False <class 'str'> <class 'str'> <class 'str'>这个时候str函数就将 int值，float浮点值，bool布尔值
# 转换成str字符串值
#str()函数将其他数据类型转换成字符串，也可以用引号转换，用引号转简单
#int()函数将其他数据类型转换成整数，但是文字类和小数类字符串是无法转换成为整数的
#float()函数将其他数据类型转换成为浮点数，文字类无法转换成整数，整数转浮点数，末尾为.0

print('w3',type(int(w3)))#也是可以用引号转换
print(float(w1),type(float(w1)))
print('w1',type(float(w1)))#都可以用引号进行转换

注释

1
2
3
4
5
# 天空北慕·
# 开发时间：2022/11/21 23:05
print('你好')
'''嘿嘿，
多行注释'''

输入函数input()

1
2
3
4
5
6
7
8
9
10
11
# 天空北慕·
# 开发时间：2022/11/21 23:17
#wo=input('你想要什么礼物')
#print(wo,type('wo'))
#从键盘录入两个整数，计算两个数的和
a=int(input('请输入一个加数:'))#可以在这直接进行转换，将输入的值转为int值
#a=int(a)#  将转换后得值存入a中
b=int(input('请输入另一个整数:'))
#b=int(b)
print(type(a),type(b))
print(a+b)

算术运算符中的标准运算符

1
2
3
4
5
6
7
8
9
# 天空北慕·
# 开发时间：2022/11/21 23:43
print(1+1)#加法运算
print(1-1)#减法运算
print(1/1)#除法运算
print(1*1000)#乘法运算
print(11//2) #整除运算  只取整数，不取小数
print(11%2)#取余计算
print(2**3)#表示的是2的3次方

标准运算中一正一负，向下取整

1
2
3
4
5
6
7
8
9
10
# 天空北慕·
# 开发时间：2022/11/21 23:51
print(9//4)#2
print(-9//-4)#2
print(-9//4)#-3一正一负的整数公式，向下取整
print(9//-4)#-3


print(9%-4)#-3  公式   余数=被除数-除数*商   9-（-4）*（-3）9-12-->  -3
print(-9%4)#3                             -9-4*(-3)  -9+12-->   3

赋值运算符

赋值运算符应该是最为常见的运算符，它的作用是将右边的值赋给左边的变量。下面的例子演示了赋值运算符和复合赋值运算符的使用。

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
#赋值运算符，计算顺序是从右到左
a=3+4
print(a)
print('--链式赋值---')
b=c=d=100
print(b,id(b))
print(c,id(c))
print(d,id(d))

print(('---支持参数赋值---'))
a=20
a+=50
print(a)
a-=20
print(a)
a*=20
print(a)
a/=30
print(a)
a//=20
print(a)
a%=3
print(a)
print('----支持系列解包赋值---')
c,v,b=20,30,40
print(c,v,b)
#左右变量的个数和值得个数要对应，要不然就会报错
z,x=10,21
print('---交换两个变量的值--')
print('交换之前:',z,x)
#交换
z,x=x,z,
print(z,x)

比较运算符

比较运算符和逻辑运算符

比较运算符有的地方也称为关系运算符，包括==、!=、<、>、<=、>=，我相信没有什么好解释的，大家一看就能懂，唯一需要提醒的是比较相等用的是==，请注意这个地方是两个等号，因为=是赋值运算符，我们在上面刚刚讲到过，==才是比较相等的比较运算符。比较运算符会产生布尔值，要么是True要么是False。

逻辑运算符有三个，分别是and、or和not。and字面意思是“而且”，所以and运算符会连接两个布尔值，如果两个布尔值都是True，那么运算的结果就是True；左右两边的布尔值有一个是False，最终的运算结果就是False。相信大家已经想到了，如果and左边的布尔值是False，不管右边的布尔值是什么，最终的结果都是False，所以在做运算的时候右边的值会被跳过（短路处理），这也就意味着在and运算符左边为False的情况下，右边的表达式根本不会执行。or字面意思是“或者”，所以or运算符也会连接两个布尔值，如果两个布尔值有任意一个是True，那么最终的结果就是True。当然，or运算符也是有短路功能的，在它左边的布尔值为True的情况下，右边的表达式根本不会执行。not运算符的后面会跟上一个布尔值，它的作用是得到与该布尔值相反的值，也就是说，后面的布尔值如果是True运算结果就是False，而后面的布尔值如果是False则运算结果就是True。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#比较运算符   比较运算符的结果为BOOL类型
a,b=10,20
print('a>b吗',a>b)#false
print('a<b吗',a<b)  #是
print('a<=b吗',a<=b)#是
print('a>=b吗',a>=b)#不是
print('a==b吗',a==b)#a等于b吗   no
print('a!=b吗',a!=b)#a不等于b吗   yes
#一个'='是赋值运算符，==两个是比较运算符
#一个变量由三部分组成，标识，类型，值
#==比较的是值
#比较对象的标识，是is
a=10
b=10
print(a==b)#a和b的值相等
print(a is b)#a和b的标识相等
qq1=[11,22,33,44]
ww2=[11,22,33,44]
print(qq1==ww2)
print(qq1 is ww2)
print(id(qq1))
print(id(ww2))
print(qq1 is not ww2)
print(a is not b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
"""
比较运算符和逻辑运算符的使用

"""
flag0 = 1 == 1
flag1 = 3 > 2
flag2 = 2 < 1
flag3 = flag1 and flag2
flag4 = flag1 or flag2
flag5 = not (1 != 2)
print('flag0 =', flag0)    # flag0 = True
print('flag1 =', flag1)    # flag1 = True
print('flag2 =', flag2)    # flag2 = False
print('flag3 =', flag3)    # flag3 = False
print('flag4 =', flag4)    # flag4 = True
print('flag5 =', flag5)    # flag5 = False

说明：比较运算符的优先级高于赋值运算符，所以flag0 = 1 == 1先做1 == 1产生布尔值True，再将这个值赋值给变量flag0。print函数可以输出多个值，多个值之间可以用,进行分隔，输出的内容之间默认以空格分开。

内置函数range()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#内置函数range()三种创建方式
'''第一种，只有一个参数(小括号中只有一个数)'''
q=range(20)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],默认从零开始，默认相差1，称为步长
print(q)#(0,20)
print(list(q))#用于查看range中的整数序列    --->list是列表的意思
'''第二种创建方式，给两个参数，(小括号中给两个数)'''
w=range(2,10)#[2, 3, 4, 5, 6, 7, 8, 9],指定了起始值，从2到10（不包含10），默认步长为1
print(w)
print(list(w)
'''第三种创建方式，给三个参数，(小括号中给三个数)'''
a=range(1,30,2)#[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]
print(a)
print(list(a))    
'''判断指定的整数 在序列中是否存在 in  not in'''
print(10 in a)#10不在当前的序列中
print(9 in a)#9，在当前的序列中    
print(10 not in a)  #10的确不在当前序列中  对
print(9 not in a)   #判断错
s=range(1,101,1)
print(s)
print(list(s))#

循环结构while()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#a=1
#判断条件表达式
#while a<10:  #循环体
#print (a)
# a+=1
#计算0到4之间的累加和
'''
四步循环法
1，初始化的变量
2，条件判断
3，条件执行体（循环体）
4，改变变量
总结：初始化的变量与条件判断的变量为同一个'''
sum=0#用来存储累加和
'''初始化变量为0'''
q=0
'''条件判断'''
while q<5:
    '''条件执行体（循环体）'''
    sum+=q
    #改变变量
    q+=1
print('和为:',sum)

循环语句练习题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
'''计算1到100之间的偶数和'''
sum=0 #存入偶数和
'''初始化变量'''
a=1
'''条件判断'''
while a<=100:
    '''条件执行体（循环体）'''
    #条件判断是否是偶数
    if not bool(a%2):      #a%2==0:
        #改变判断条件即可实现偶数和由奇数和的变化
        sum+=a
        '''改变变量'''
    a+=1
    print ('1到100之间的偶数和',sum)

for-in语句循环

1
2
3
4
5
6
7
8
for item in 'python':  #第一次取出来的值是p，然后将值赋值在item中，将item中输出
    print (item)    
    #range()产生一整个序列，也是一个可迭代对象
for i in range(20):
    print (i)
    #如果在循环过程中不需要使用到自定义变量，可将自定义变量写为“_”
for _ in range(5201314 ):
    print('你好你好')

输出100到999之间的水仙花数

通过for语句循环，if进行判断，然后找出水仙花数

1
2
3
4
5
6
7
8
9
   #举例
for i in range(100,1000):
    q=i%10
    shi=i//10%10
    bai=i//100
    # print(q,shi,bai )
    #判断
    if q**3+shi**3+bai**3==i:
        print(i)

流程控制语句break

break语句，用于结束循环结构，通常和分支结构if一起使用

1
2
3
4
5
6
7
8
9
#break语句，用于结束循环结构，通常和分支结构if一起使用
'''要求从键盘录入密码，最多录入三次，如果正确就结束'''
for i in range(3):
    q=input('请输入密码:')
    if q =='9999':
        print('密码正确')
        break
    else:
        print('密码不正确')

break语句循环体#

break语句是语句循环体，可以作为截止循环并重新进入下一次循环

1
2
3
4
5
6
7
8
9
a=0
while a<3:
    q=input('请输入密码；')
    if q=='0000':
        print('密码正确')
        break
    else:
        print('密码不正确')
        a+=1

流程控制语句continue

continue语句 用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#continue语句 用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用，
'''要求输出1到50之间所有5的倍数，5，10,15,25。。。
5的倍数的共同点：  和5的余数为0的数都是5的倍数
要求是使用continue实现
'''
for item in range (1,51): #通过for循环语句，求出1到51之间的5的倍数，
    if item%5==0:
        print(item)

print ('----使用coutinue----')
for item in range (1,51):
    if item%5!=0:
     continue #continue语句是为了结束循环，同时进入下一次循环。
print (item)