第二章

变量和简单类型

单行注释和多行注释
Python是弱类型语言
Python变量的特征
Python变量命名规则
Python关键字和内置函数
Python支持的各种数值类型
Python字符串入门
拼接字符串的方法
repr和字符串
使用input和raw_input 获取用户输入
长字符串和原始字符
字符串格式化
字符串的相关方法
Python的赋值运算符
Python的算术运算符
Python的位运算符
Python的扩展后的赋值运算符
Python的索引运算符
Python的比较运算符
Python的逻辑运算符
Python的三目运算符
Python的in运算符

单行注释和多行注释

#这是单行注释

'''
这是
多行
注释
'''

变量
Python 使用等号“＝”作为赋值运算符，例如

 a = 20

这个过程就被称为赋值：将 20 赋值给变量a

Python是弱类型语言
Python 门弱类型语言，弱类型包含两方面的含义
①所有的变量无须声明即可使用，或者说对从未用过的变量赋值就是声明了应变量；
②变量的数据类型可以随时改变，同一个变量可以一会儿是数值型，一会儿是字符串型。

a = 20
#这时a是int类型
a = 'r'
type(a) 
# a又变成str类型

使用 print 函数输出变量
print（）函数可以输出一个或多个变量

user_name = 'Char'
user_age = 8 
＃同时输出多个变量和字符串
print ('读者名 ',  user_name ，'年龄 ：',  user_age)
#读者名: Char 年龄: 8

如果读者希望改变默认的分隔符，可使用sep进行设置

print('读者名:', user_name, '年龄:', user_age, sep='$')
#读者名:$Char$年龄:$8

在默认情况下， print函数输出之后自动换行，这是因为 print函数的end参数的默认值是“＼n ”，这个就代表了换行，如果希望 print函数输出之后不会换行，将end参数修改为" "

user_name = 'Char'
user_age = 8
print('读者名:', user_name, end= ' ')
print('年龄:', user_age)
#读者名: Char 年龄: 8
#没有换行
print('读者名:', user_name)
print('年龄:', user_age)
#读者名: Char
#年龄: 8
#自动换行

file参数指定print函数的输出目标， file参数的默认值为sys.stdout，该默认值代表了系统标准输出，也就是屏幕，因此 print（）函数默认输出到屏幕。如果改变file参数值输出将到特定文件中

f = open( 'first/novel/threekingdom.txt', 'w', encoding = 'utf-8')
print('沧海月明珠有泪', file=f)
print('蓝回日暖玉生烟', file=f)
f.close()
#打开.txt文件确认，文件内如下两行文字
# 沧海月明珠有泪
# 蓝回日暖玉生烟

变量的命名规则
Python是区分大小写的，因此abc，Abe 是两个不同的标识符

①标识符可以由字母、数字、下画线组成，其中数字不能开头
②标识符不能是Python的关键字，但可以包含关键字。
③标识符不能包含空格

abc_xyz # 合法。
HelloWorld # 合法。
abc # 合法
xyz#abc # 不合法，标识符中不允许出现“＃”号。
7abc # 不合法，标识符不允许数字开头。

Python的关键字和内置函数

①如果开发者使用关键字作为变量名， Python解释器会报错。
②如果开发者使用内置函数的名字作为变量名， Python解释器不会报错，只是该内置函数
就被这个变量覆盖了，该内置函数就不能使用了。

＃导入 keyword 模块
import keyword 
＃显示所有关键字
keyword.kwlist

数值类型

整型
Python的整型支持各种整数值

＃定义变量 ，赋值为 56
a = 56 
print(a) 
＃为 赋值一个大整数
a = 9999999999999999999999 
print(a) 
# type （）函数用于返回变量的类型
print (type (a)) 
#

Python的整型支持None值（空值）

a = None
print(a)
#None
print(type(a))
#

Python的整型数值有四种表示形式：
十进制形式：最普通的整数就是十进制形式的整数
二进制形式：以0b或0B开头的整数就是二进制形式的整数
八进制形式：以0o或0O开头的整数就是八进制形式的整数
十六进制形式：以0x或0X开头的整数就是十六进制形式的整数，其中10_15分别以af来表示

valuel1 = 0x13
valuel2 = 0XaF
print('valuel1的值为：', valuel1)
#valuel1的值为： 19
print('valuel2的值为：', valuel2)
#valuel2的值为： 175
bin_val = 0b111
print('bin_val的值为：', bin_val)
#bin_val的值为： 7
oct_val = 0o54
print('oct_val的值为：', oct_val)
#oct_val的值为： 44

为了提高数值（包括浮点型）的可读性， Python 3.x允许为数值（包括浮点型）增加下画线作为分隔符

one_million = 1_000_000
print(one_million)
#1000000

浮点型
Python的浮点型有两种形式
①十进制形式：这种形式就是平常简单的浮点数，如：3.14，浮点数必须包含一个小数点，否则会被当成整数类型处理
②科学计数形式：如：5.12e2（5.12*10^2）只有浮点型数值才可以用科学计数形式表达
另外，Python不允许除以0，不管是整型值还是浮点型值

afl = 5.2345556
print(afl)
#5.2345556
af2 = 25.2345
print(af2)
#25.2345
f1= 5.12e2
print(f1)
#512.0
f2 = 5e3
print(f2, type(f2))
#5000.0

复数
Python支持复数，复数的虚部用j或者J来表示
（如果需要在程序中对复数进行计算，可导入cmath库，该库包含各种支持复数运算的函数）

a1 = 3 + 0.2j
print(a1, type(a1))
#(3+0.2j) 
a2 = 4 - 0.1j
print(a1 + a2)
#(7+0.1j)
import cmath
a3 = cmath.sqrt(-1)
print(a3)
#1j

字符串入门
1.字符串和转义字符
字符串的意思就是‘一串字符’，比如‘hello word’是一个字符串，‘how old are you’也是一个字符串，Python要求字符串必须用‘’或“”括起来。
如果字符串内容本身包含了单引号或双引号，此时就需要进行特殊处理
①使用不同的引号将字符串括起来
②对引号进行转义

str3 = 'I'm a coder'

上面的字符串中包含了单引号，此时python会将字符串的单引号与第一个单引号号配对，这样就会把I当成字符串，而后面的m a coder 就变成了多余的内容，从而导致语法错误。
为了避免上述情况

str3 = “I'm a coder”

上面代码使用双引号将字符串括起来，此时Python就会把字符串中的单引号当成字符串内容，而不是和字符串开始的引号配对
也可以使用单引号将字有串括起来

str4 = '"Spring is here，let us jam！"，said woodchuck'

或者使用转义字符

str5 = '"we are scared, Let\' s hide in the shade ", says the bird '

2.拼接字符串
如果直接将两个字符串紧挨着谢在一起，Python就会自动拼接他们

str = "hey,"'charlie'
print(str)
#hey,charlie

上面的这种写法只是字符串的特殊方法，不能用于真正的字符串拼接，Python使用加号来实现字符串拼接

s1 = 'python'
s2 = ' is funny'
s = s1 + s2
print(s)
# python is funny

3.repr 和字符串
Python不允许数字和字符串直接拼接，必须要把数字转化成字符串
须先将数值转换成字符串
为了将数值转换成字符串，使用 str（）或 repr（）函数

x = '这本书的价格是:'
y = str(98)
print(x+y)
# 这本书的价格是:98
y = repr(98)
print(x+y)
# 这本书的价格是:98

str是Python内置的类型，repr是个函数。
repr 可以以Python 表达式的形式来表示值。

st = ' I will play my fife '
print(st)
print(repr(st))
#  I will play my fife 
# ' I will play my fife '

通过上面的输出可以看出，如果直接打印输出字符串，只能看到字符串的内容，没有引号，而使用repr对字符串进行处理后输出，将可以看到带引号的字符串，这就是字符串的Python的表达式形式
4.使用input和raw_input（Python2.X）
input将输入的内容放入字符串，因此不论输入任何内容，都返回一个字符串

s = input("输入一个数字：")
#8
print(s)
print(type(s))
# 8
#

5.长字符串
前面介绍多行注释时提到使用''' ''' 引号（单引号、双引号都行）来包含多行注释内容，其实这是长字符串写法，只是由于在长字符串中可以放置任何内容，包括放置单引号、双引号都可以，如果所定义的长字符串没有赋值给任何变量，那么这个字符串就相当于被解释器忽略了，也就相当于注释掉了。

s = '''
a,
b,
ggg
gggg
ggg
'''
print(s)

# a,
# b,
# ggg
# gggg
# ggg

Python 还允许使用转义字符＼换行符进行转义，转义之后的换行符不会“中断”字符串

s = 'The quick brown fox\
jumps over the lazy'
print(s)
# The quick brown foxjumps over the lazy

6.原始字符串
因为反斜线有特殊意义，当字符串中出现反斜线时就需要转义，如:G:\publish\coes\02\2.4,就要写成G:\publish\coes\02\2.4,这样写比较麻烦，
我们以“r ”为原始字符串开头原始字符串就不会把反斜线当成特殊字符处理了

s = r'G:\publish\coes\02\2.4'
print(s)
#G:\publish\coes\02\2.4

如果原始字符串中包含引号，程序同样需要对引号进行转义，但是不能使用 \ 来转义

s = r' "Let \' s go"， said Charlie'
print(s)
# "Let \' s go"， said Charlie

使用 \ 转义的输出是直接把 \打印出来了
7.bytes
字符串（str）由多个字符组成，以字符为单位进行操作， byte 是由多个字节组成，以字节为单位进行操作
bytes和str 除操作的数据单元不同之外，它们支持的所有方法都基本相同， bytes 也是不可变序列
bytes 保存的就是原始的字节（二进制格式）数据，因此 bytes 对象可用于在网络上传输数据，也可用于存储各种二进制格式的文件

如果字符串内容都是 ASCII 字符，则可以通过直接在字符串之前添加来构建字节串值
调用 bytes函数（其实是 bytes 构造方法）将字符串按指定字符集转换成字节串
如果不指定字符集，默认使用 UTF 字符集。
创建一个空的bytes值

b2 = b''
print(b2)
print(type(b2))
# b''
#

通过前缀b指定hello为bytes类型的值

b2 = b'hello'
print(b2)
print(type(b2))
# b'hello'
#

调用bytes方法将字符串改成bytes类型的值

b3 = bytes('今天是星期二', encoding ='UTF-8')
print(type(b3))
#

利用字符串的 encode 方法编码成 bytes ，默认使用 UTF-8 字符集

b4 = '今天是星期二'.encode('UTF-8')
print(b4)
#b'\xe4\xbb\x8a\xe5\xa4\xa9\xe6\x98\xaf\xe6\x98\x9f\xe6\x9c\x9f\xe4\xba\x8c'

（将 bytes 对象解码成字符串默认使用 UTF 进行解码）
在Python3中，str类型的对象都是Unicode，因此对于str类型的对象只有encode方法，没有decode方法（若运行，会报错）。

深入使用字符串
1.转义字符
中间没有空格

转义字符	说明
\b	退格
\n	换行
\t	制表
\r	回车
\ '	单引号
\ ''	双引号
\ \	反斜杠

s = 'Hello\nCharle\nGood\nMorning'
print(s)
# Hello
# Charle
# Good
# Morning
s2 = '商品名 \t\t 单价\t\t数量\t\t总价'
s3 = '疯狂Java讲义\t l08 \t\t2   \t\t216'
print(s2)
print(s3)
# 商品名        单价     数量      总价
# 疯狂Java讲义   l08        2           216

2.字符串格式化
使用%对各类型的数据进行格式化输出

price = 108
print('the book’s price is %s' % price)
# the book’s price is 108

此代码分为三部分：
第一部分是格式，字符串（它相当于字符串模板），该格式化字符串中包含一个%s 占位符，它会被第三部分的变量或表达式的值代替，第二部分部分固定使用%作为分隔符。
格式化字符串中的%s被称为转换说明符
如果格式化字符串包含多个占位符，第三部分也应该对应地提供多个变量，并且使用圆括号将这些变量括起来

name = 'Dive'
age  = 45
print('%s的年龄是%s'%(name, age))
#Dive的年龄是45

也可以使用如下方法（3.6以上版本）

print(f'{name}的年龄是{age}')

转换说明符
注意：二进制是0b开头，八进制是0o开头，十六进制是0x开头

转换说明符	说明
i/d	将整数、浮点数转换成十进制表示，并将其格式化到指定位置
o	将整数、浮点数转换成八进制表示，并将其格式化到指定位置
x	将整数、浮点数转换成十六进制表示，并将其格式化到指定位置
e	将整数、浮点数转换成科学计数法表示，并将其格式化到指定位置（小写e）
E	将整数、浮点数转换成科学计数法表示，并将其格式化到指定位置（小写E）
f	将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认小数点后保留6位）
F	将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认小数点后保留6位）
g	自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位使用科学计数法），并将其格式化到指定位置（如果是科学计数这是e）
G	自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位使用科学计数法），并将其格式化到指定位置（如果是科学计数这是E）

print("将二进制转换成十进制::%d" % 0b1010)
#10
print("将八进制转换成十进制::%d" % 0o10)
#8
print("将十六进制进制转换成十进制::%d" % 0x10)
#16
print("将十进制进制进制转换成八进制::%o" % 10)
#12
# 科学计数法表示
print("%e" % 18889999)
#1.889000e+07
print("保留三位小数：%.3f" % 3.14159265)
#3.142

3.序列相关方法
python字符串的索引从0开始，0，1，2......后面依此类推。

s = 'Hello，Charle！Good Morning！'
print(s[0])
#H
print(s[-1])
#！
print(s[:4])
#Hell
print(s[:-5])
#Hello，Charle！Good Mor
print(s[::-1])
# ！gninroM dooG！elrahC，olleH

4.大小写相关方法
dir：列出指定类或模块包含的全部内容（包括函数、方法、类、变量等）。
help：查看某个函数或方法的帮助文档。

str类中与大小写相关的常用方法如下：
~ title：将每个单词首字母改为大写
~ lower：将整个字符串改为小写
~ upper：将整个字符串改为大写

s = 'hello，charle！good morning！'
print(s.title())
s1=s.upper()
print(s1)
print(s1.lower())
# Hello，Charle！Good Morning！
# HELLO，CHARLE！GOOD MORNING！
# hello，charle！good morning！

5.删除空白
str 还提供了如下常用的方法来删除空白。
~ stri：删除字符串前后空白。
~ strip：删除字符串前面（左边）的空白。
~ rstrip：删除字符串后面（右边）的空白。
需要说明的是：Python的str是不可变的（不可变的意思是指，字符串一旦形成，它所包含的
字符序列就不能发生任何改变），因此这个方法只是返回字符串前面或后面空白被删除之后的副本，并没有真正改变字符串本身

s = '  hello，charle！good morning！  '
print(s.lstrip())
#hello，charle！good morning！
print(s.rstrip())
#  hello，charle！good morning！
print(s.strip())
#hello，charle！good morning！
print(s)
#  hello，charle！good morning！

最后输出s后可以看出s并没有改变

也可以指定删除内容

s = 'hello，charle！good morning'
print(s.lstrip('hell'))
#o，charle！good morning！
print(s.rstrip('ning'))
#hello，charle！good mor！
print(s)
#hello，charle！good morning！

查找、替换相关方法
str提供了如下常用的执行查找、替换等操作的方法：
~ startswith判断字符串是否以指定子串开头。
~ endswith判断字符串是否以指定子串结尾
~ find查找指定子串在字符串中出现的位置，如果没有找到指定子串，则返回 -1
~ index查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发 ValueError错误。
~ place使用指定子串替换字符串中的目标子串
~ translate使用指定的翻译映射表对字符串执行替换。

s = 'crazyit.org is a good site'
print(s.startswith('cra'))
#判断是否以cra开头
# True
print(s.endswith('te'))
#判断是否以te结尾
# True
print(s.find('is'))
#查找is出现的位置
#12
print(s.index('org'))
#从索引开始查找org出现的位置
#8
print(s.find('org', 9))
#从索引9处开始查找org出现的位置
# -1
#print(s.index('org', 9))
#substring not found
print(s.replace('is','***'))
#crazyit.org *** a good site
print(s.replace('it', 'xxx', 1))
#将字符串中一个it改写成xxx
#crazyxxx.org is a good site
table ={97:945, 116:964}
print(s.translate(table))
#定义翻译映射表 a(97)->α(945) t(116)->τ(964)
# crαzyiτ.org is α good siτe

使用translate时要记住字符编码，我们也可以用maketrans方法，该方法无需记住字符编码就可返回映射表

print(s.maketrans('at','ατ'))
#{97: 945, 116: 964}

7.分割、连接方法
split：将字符串按指定分割符分割成多个短语
join：将多个短语连接成字符串

s = 'crazyit.org is a good site'

print(s.split(' '))
#等同于s.split() 按空格分割
#['crazyit.org', 'is', 'a', 'good', 'site']
print(s.split(' ', 2))
#等同于s.split(None, 2)
#按两个空格分隔
#['crazyit.org', 'is', 'a good site']
print('*'.join(s))
#c*r*a*z*y*i*t*.*o*r*g* *i*s* *a* *g*o*o*d* *s*i*t*e

运算符
1.赋值运算符
Python 使用“＝”作为赋值运算符

st = 'python'
pi = 3.14
T = True

除此之外，也可使用赋值运算利将一个变量的值赋给另一个变量

st = pi
print(st)
# 3.14

Python 赋值表达式是有值的，赋值表达式的值就是被赋的值

a = b = c = 20

赋值运算符还用于将表达式的值赋给变量

d1 = 12.34
# 将表达式的值赋给 d1
d2 = d1 + 5
# 输出 d2 的值
print(d2)
# 17.34

2.算术运算符
Python 支持所有的基本算术运算符，这些算术运算符用于执行基本的数学运算

num1 = 9 + 2
print("加:%d" % num1)
num2 = 9 - 2
print("减:%d" % num2)
num3 = 9 * 2
print("乘:%d" % num3)
num4 = 9 / 2
print("除:%d" % num4)
# 取整除
num5 = 9 // 2
print("取整除:%d" % num5)
# 取余数
num6 = 9 % 2
print("取余数:%d" % num6)
# 取次幂
num7 = 9 ** 2
print("取次幂:%d" % num7)

3.位运算符

运算符	说明
＆	按位与
｜	按位或
^	按位异或
~	按位取反
<<	左位移运算符
>>	右位移运算符

按位与
运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1，否则为0。参与运算的数以补码方式出现。
例如：9&5可写算式如下：
00001001 (9的二进制补码)
&00000101 (5的二进制补码)
00000001 (1的二进制补码)
可见9&5=1。
按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ，保留低八位，可作a&255运算（255 的二进制数为0000000011111111）。
按位或
运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。
例如：9|5可写算式如下：
00001001
|00000101
00001101 (十进制为13)
可见9|5=13
按位异或
运算符“^{”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9}5可写成算式如下：
00001001
^00000101
00001100 (十进制为12)
求反
运算符_{为单目运算符，具有右结合性。其功能是对参与运算的数的各二进位按位求反。例如}9的运算为：
~(0000000000001001)
结果为：1111111111110110
左移
运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。例如：
a<<4
指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。
右移
运算符“>>”是双目运算符。其功能是把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。例如：
设 a=15，
a>>2
表示把000001111右移为00000011(十进制3)。
注意：对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。

4.索引运算符
索引运算符就是方括号，在方括号中既可使用单个索引值，也可使用索引范围。实际上，在使用索引范围时，还可指定步长。

a = 'asdfghknuukl'
print(a[2:9:2])
# dgku
print(a[2:11:3])
# dhu

5.比较运算符
Python 支持的比较运算符如下：
(>)大于，如果运算符前面的值大于后面的值，则返回 True；否则返回 False。
(>=)大于或等于，如果运算符前面的值大于或等于后面的值，则返回 True；否则返回 False。
(<)小于，如果运算符前面的值小于后面的值，则返回 True；否则返回 False。
(<=)小于或等于，如果运算符前面的值小于或等于后面的值，则返回 True；否则返回 False。
(==)等于，如果运算符前面的值等于后面的值，则返回 True；否则返回 False。
(!=)不等于，如果运算符前面的值不等于后面的值，则返回 True；否则返回 False。
(is)判断两个变量所引用的对象是否相同，如果相同则返回 True。
(is not)判断两个变量所引用的对象是否不相同，如果不相同则返回 True。

# 输出True
print("5是否大于 4：", 5 > 4)
# 输出False
print("3的4次方是否大于等于90.0：", 3 ** 4 >= 90)
# 输出True
print("20是否大于等于20.0：", 20 >= 20.0)
# 输出True
print("5和5.0是否相等：", 5 == 5.0)
# 输出False
print("True和False是否相等：", True == False)

6.逻辑运算符

逻辑运算符	含义	基本格式	说明
and	逻辑与运算，等价于数学中的“且”	a and b	当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。
or	逻辑或运算，等价于数学中的“或”	a or b	当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。
not	逻辑非运算，等价于数学中的“非”	not a	如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反。

print(not False)
# 5>3 返回 True 20.0 大于 10 ，因此结果返回 True
print(5 > 3 and 20.0 > 10)
# 4>=5 返回 False 返回 True ，求或后返回 True
print(4 >= 5 or 'C' > 'a')

7.三目运算符

x = 3
y = 6 
#一般的写法
if (x == y):
    print("两数相同！")
elif(x > y):
    print("较大的数为：",x)
else:
    print("较大的数为：",y)  
# 三目运算符写法
print(x if(x>y) else y)

8.in运算符
in 运算符可判断某个成员是否在序列中，例如判断某个字符是否在某个字符串中。in 的反义词是 not in，判断的结果都是 bool 型值。

print('on' in 'python.org')                 
# 输出：True
print('on' not in 'python.org')          
# 输出：False
print('linux' not in 'python.org')      
# 输出：True

9.运算符的结合性和优先级

运算符有不同的优先级，优先级高的会先计算。按优先级从高到低排列

第二章

变量和简单类型

你可能感兴趣的:(第二章)