第一章 Python初探
目录
一、python类别
二、python编码
2.1 编码类型
2.1.1 ASCII编码
2.1.2 GB2312编码
2.1.3 GBK编码
2.1.4 ANSI（扩展的ASCII编码）
2.1.5 Unicode编码
2.2 python的编码问题
2.3 字符编码检测-chardet
2.4 判断是否是字符串-isinstance()
2.5 进制转换
2.5.1 bin( number )：
2.5.2 oct( number )：
2.5.3 hex(number )：
2.5.4 int()：
三、python基础
3.1 help()
3.2 dir()
3.3 数据类型和变量
3.3.1 常量
3.3.2 整数、布尔类型、浮点数和复数
3.3.3 逻辑值、与或非
3.3.4 变量
3.3.5数据类型
3.3.6 基本数据类型间的转换
3.4 对象
3.5 保留字
3.6 物理行和逻辑行
3.7 单行注释和多行注释
3.8 原码、反码、补码
3.8.1 机器数
3.8.2 真值
3.8.3 原码
3.8.4 反码
3.8.5 补码
3.8.6 为何要使用原码, 反码和补码
3.9 运算符和表达式
3.9.1 算术运算符
3.9.2 比较运算符
3.9.3 赋值运算符
3.9.4 逻辑运算符
3.9.5 位运算符
3.9.6 成员运算符
3.9.7 身份运算符
3.9.8 运算符的优先级
3.9.9 operator包的应用
3.10 标准输入、标准输出和错误输出
3.10.1 标准输出
3.10.2 标准输入
3.10.3 错误输出
3.10.4 退出程序
3.11 random随机函数
3.12 浮点数计算之坑
3.12.1 decimal模块
四、课堂练习题
4.1 输入两个数，判断两个数是正数还是负数
4.2 找到列表中最大和第二大的值
4.3 随机生成一个10位数字；随机生成一个10位字母
4.4 生成3个数字、3个小写字母、3个大写字母
4.5 二进制与十进制互转
一、python类别
CPython、JPython、IronPython（为了和java，.net更好的调用，所以才有JPython、IronPython）
# 输出：AaBb...Zz
>>> result=""
>>> for i in range(26):
... result += chr(65+i)+chr(97+i)
...
>>> print(result)
AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz
>>> import string
>>> dir(string)
['Formatter', 'Template', '_ChainMap', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_sentinel_dict', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
# 输出：ACEGIKMOQSUWY
>>> result =""
>>> for i in range(0,26,2):
... result += chr(65+i)
...
>>> print(result)
ACEGIKMOQSUWY
# 输出：1a2b...26z
>>> result =""
>>> for i in range(26):
... result += str(i+1)+chr(97+i)
...
>>> print(result)
1a2b3c4d5e6f7g8h9i10j11k12l13m14n15o16p17q18r19s20t21u22v23w24x25y26z二、python编码
2.1 编码类型
2.1.1 ASCII编码
2.1.2 GB2312编码
2.1.3 GBK编码
2.1.4 ANSI（扩展的ASCII编码）
2.1.5 Unicode编码
2.2 python的编码问题
>>> s="中国" # Unicode类型（默认类型），可以用于计算机内存中，不能用于文件存储和网络传输
>>> type(s)
>>> s=s.encode("utf-8") # 编码成bytes类型，可用于文件存储和网络传输
>>> type(s)
>>> s
b'\xe4\xb8\xad\xe5\x9b\xbd'
>>> s+"中国"
Traceback (most recent call last):
File "", line 1, in
TypeError: can't concat str to bytes
>>> s+s
b'\xe4\xb8\xad\xe5\x9b\xbd\xe4\xb8\xad\xe5\x9b\xbd'
>>> s=s+s
>>> s.decode("utf-8")
'中国中国'
# Unicode（str类型）===>encode()===>bytes类型
# bytes类型===>decode()===>Unicode（str类型）
>>> s="中国" # str类型
>>> s.decode("utf-8")
Traceback (most recent call last):
File "", line 1, in
AttributeError: 'str' object has no attribute 'decode'. Did you mean: 'encode'?
>>> s.encode("utf-8")
b'\xe4\xb8\xad\xe5\x9b\xbd'
>>> s=s.encode("utf-8")
>>> s
b'\xe4\xb8\xad\xe5\x9b\xbd'
>>> s.encode("gbk")
Traceback (most recent call last):
File "", line 1, in
AttributeError: 'bytes' object has no attribute 'encode'. Did you mean: 'decode'?
>>> s.decode("utf-8")
'中国' 解决py文件中文乱码的问题：
1、把程序文件，保存为utf-8编码
2、程序文件头不声明编码，或者声明#encoding=utf-8
2.3 字符编码检测-chardet
注意： chardet检测时，被检测的字符必须足够多，过少的话会不准
C:\Users\asus>pip install chardet
Collecting chardet
Downloading chardet-4.0.0-py2.py3-none-any.whl (178 kB)
|████████████████████████████████| 178 kB 285 kB/s
Installing collected packages: chardet
Successfully installed chardet-4.0.0
>>> import chardet
>>> s="今天星期一，天气晴！"
>>> s=s.encode()
>>> s
b'\xe4\xbb\x8a\xe5\xa4\xa9\xe6\x98\x9f\xe6\x9c\x9f\xe4\xb8\x80\xef\xbc\x8c\xe5\xa4\xa9\xe6\xb0\x94\xe6\x99\xb4\xef\xbc\x81'
>>> chardet.detect(s)
{'encoding': 'utf-8', 'confidence': 0.99, 'language': ''}
2.4 判断是否是字符串-isinstance()
>>> s="中国"
>>> s
'中国'
>>> isinstance(s,str)
True
>>> a=s.encode()
>>> isinstance(a,bytes)
True
>>> isinstance(a,str)
False2.5 进制转换
2.5.1 bin( number )：
内置函数，接收一个数字，可以是二进制数、八进制数、十进制数和十六进制数，返回以0b开头的二进制字符串表示
>>> bin(0b111)
'0b111'
>>> bin(111)
'0b1101111'
>>> bin(0o11)
'0b1001'
>>> bin(0xA1)
'0b10100001'
>>> type(bin)
2.5.2 oct( number )：
内置函数，接收一个数字，可以是二进制数、八进制数、十进制数和十六进制数，返回以0o开头的八进制字符串表示
>>> type(oct)
>>> oct(0b1111)
'0o17'
>>> oct(0o167)
'0o167'
>>> oct(16)
'0o20'
>>> oct(0xFFF)
'0o7777' 2.5.3 hex(number )：
内置函数，接收一个数字，可以是二进制数、八进制数、十进制数和十六进制数，返回以0x开头的十六进制字符串表示
>>> type(hex)
>>> hex(0b1001)
'0x9'
>>> hex(16)
'0x10'
>>> hex(15)
'0xf'
>>> hex(0o100)
'0x40'
>>> hex(0xAF11)
'0xaf11' 2.5.4 int()：
是一个类，构造函数如下：
int(x=0) -> integer
int(x, base=10) -> integer
函数作用：把一个数字或者字符组转换为一个整数，
参数说明：
如果没有指定任何参数返回的是数字0；
如果输入的是浮点数返回的只有整数部分，相当于向下取整；
如果给定了参数base那么x必须是字符串或bytes或bytearray instance ；
base有效的取值是0，或2-36，默认值是10，代表x是十进制；base为0表示x按照字面意思进行解析
>>> int(12.98) #将浮点数向下取整
12
>>> int('0o10',base=0) #0o代表八进制，此语句等价于int('0o10',base=8)
8
>>> int('10',base=0) #默认为十进制，此语句等价于int('10',base=10)
10
>>> int('0b1010',base=0) #0b代表二进制，等价于int('0b1010',base=2)
10
>>> int('0x10',base=0) #0o代表十六进制，等价于 int('0x10',base=16)
16
>>> int('0b1010',base=2) #表示将二进制的0b1010转换成10进制数
10
>>> int(0b10) #直接将输入的二进制转换为十进制数
2
>>> int(0o10) #直接将输入的八进制转换为十进制数
8
>>> int(0x10) #直接将输入的十六进制转换为十进制数
16
>>> int(10) #返回的数据和输入的一致
10
>>> int('15',base=16) #表示将16进制的0x15转换成10进制数
21
>>> int('15',base=8) #表示将8进制的0o15转换成10进制数
13
>>> int('15',base=10) #表示将10进制的15转换成10进制数
15
>>> int('15',base=2) #将2进制的0x15转换成10进制数,二进制只有0、1，所以会抛出ValueError异常
Traceback (most recent call last):
File "", line 1, in
ValueError: invalid literal for int() with base 2: '15' 十进制转二进制并进行加减运算：
>>> bin(3)+bin(2) #bin()返回的是字符串，直接相加的话相当于字符串的连接
'0b110b10'
>>> int(bin(3),base=2)
3
>>> int(bin(3),base=2)+int(bin(2),base=2)
5
>>> bin(int(bin(3),base=2)+int(bin(2),base=2))
'0b101'>>> a=9
>>> bin(a)
'0b1001'
>>> type(bin(a))
>>> bin(a)[2:]
'1001'
>>> "00"+bin(a)[2:]
'001001'
>>> bin(a)[2:].zfill(len(bin(9)))
'001001'
# 格式化字符
>>> "abc".zfill(8)
'00000abc'
>>> "abc".ljust(8,"*")
'abc*****'
>>> "abc".rjust(8,"*")
'*****abc'
>>> "abc".center(8,"*")
'**abc***' 三、python基础
3.1 help()
>>> help("print")
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.3.2 dir()
>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']3.3 数据类型和变量
3.3.1 常量
# -*-coding:utf-8-*-
# Filename:const.py
# 定义一个常量类实现常量的功能
"""
该类定义了一个方法__setattr()__,和一个异常ConstError,ConstError类继承自类TypeError。
通过调用类自带的字典__dict__，判断定义的常量是否包含在字典中。
如果字典中包含此变量，将抛出异常，否则，给新创建的常量赋值。
最后两行代码的作用是把const类注册到sys.modules这个全局字典中。
"""
class _const:
class ConstError(TypeError):pass
def __setattr__(self,name,value):
if name in self.__dict__:
raise self.ConstError
self.__dict__[name]=value
import sys
sys.modules[__name__]=_const()
print(__name__)
# test_const.py
# 测试const类
import const
const.magic = 23
print(const.magic)
const.magic = 33
C:\Users\asus>py F:\python_day1\test_const.py
const
23
Traceback (most recent call last):
File "F:\python_day1\test_const.py", line 5, in
const.magic = 33
File "F:\python_day1\const.py", line 12, in __setattr__
raise self.ConstError
const._const.ConstError 3.3.2 整数、布尔类型、浮点数和复数
>>> bool(())
False
>>> bool([])
False
>>> bool({})
False
>>> bool(None)
False
>>> bool("")
False
>>> bool(0)
False
>>> bool(False)
False
>>> bool(-1)
True3.3.3 逻辑值、与或非
>>> True and False
False
>>> True or False
True
>>> not True
False
>>> True and True
True
>>> False or False
False
"""
练习：输入两个数，判断两个数是正数还是负数
"""
#encoding=utf-8
num1 = int(input("请输入第一个数字:"))
num2 = int(input("请输入第二个数字:"))
if num1 > 0 and num2 > 0:
print("两个数字都是正数")
elif num1 < 0 and num2 < 0:
print("两个数字都是负数")
elif (num1 < 0 and num2 > 0) or (num1 > 0 and num2 < 0):
print("一正一负")
elif num1 == 0 and num2 == 0:
print("都是0")
elif (num1 == 0 and num2 != 0) or (num1 != 0 and num2 == 0):
print("一0一非0")3.3.4 变量
变量名命名规则：
➢不能以数字开头
➢标识符名称的其他部分可以由字母（大小写）、下划线（'_'）、数字（0-9）组成
➢不可以使用关键字，但是可以包含关键字
➢标识符区分大小写，例如：hisname和hisName不是一个标识符
➢以下划线开头的标识符是有特殊意义的。以单下划线开头的表示不能直接访问的实例属性，以双下划线开头的表示类的私有成员。以双下划线开头和结尾的表示特殊方法的专用标识符，如__init()__代表类的构造函数。
"单下划线"开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量。
"双下划线"开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
>>> a,b,c=1,2,3
>>> a,b = b,a
>>> a
2
>>> b
1
>>> id(a)
2436224975120
>>> id(2)
2436224975120
>>> a=10000
>>> a is 10000
:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
False
>>> a=2
>>> a is 2
:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
True
>>> a=257
>>> a is 257
:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
False
>>> id(a)
2436226013392
>>> id(257)
2436226013712
>>> a=256
>>> a is 256
:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
True
>>> id(a)
2436224983248
>>> id(256)
2436224983248 3.3.5数据类型
3.3.6 基本数据类型间的转换
| 函数 |
描述 |
| int(x [,base]) |
将x转换为一个整数 |
| float(x) |
将x转换到一个浮点数 |
| complex(real [,imag]) |
创建一个复数 |
| str(x) |
将对象x 转换为字符串 |
| repr(x) |
将对象x 转换为表达式字符串 |
| tuple(s) |
将序列 s 转换为一个元组 |
| list(s) |
将序列 s 转换为一个列表 |
| set(s) |
转换为可变集合 |
| dict(d) |
创建一个字典。d必须是一个序列 (key,value)元组。 |
| frozenset(s) |
转换为不可变集合 |
| chr(x) |
将一个整数转换为一个字符 |
| ord(x) |
将一个字符转换为它的整数值 |
| hex(x) |
将一个整数转换为一个十六进制字符串 |
| oct(x) |
将一个整数转换为一个八进制字符串 |
| bin(x) |
将一个整数转换为一个二进制字符串 |
3.4 对象
3.5 保留字
3.6 物理行和逻辑行
物理行：文件中的一行
>>> s="这是第一行前半段\
... ,这是第一行得后半段"
>>> s
'这是第一行前半段 ,这是第一行得后半段'
>>> print("hello");print(" line");print("world!")
hello
line
world!
>>> for i in range(11):
... if i % 2 == 0:
... print(i)
...
0
2
4
6
8
10
>>> [i for i in range(11) if i%2==0] # 推导列表
[0, 2, 4, 6, 8, 10]3.7 单行注释和多行注释
>>> print("hello world!") # 第一个python输出
hello world!
>>> """
... aaa
... bbb
... ccc
... """
'\naaa\nbbb\nccc\n'3.8 原码、反码、补码
3.8.1 机器数
一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.
3.8.2 真值
因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。
3.8.3 原码
原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:
[+1]原 = 0000 0001
[-1]原 = 1000 0001
第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:
[1111 1111 , 0111 1111]，即：
[-127 , 127]
3.8.4 反码
反码的表示方法是：正数的反码是其本身；负数的反码是在其原码的基础上, 符号位不变，其余各个位取反。
[+1] = [00000001]原 = [00000001]反
[-1] = [10000001]原 = [11111110]反
可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。
3.8.5 补码
补码的表示方法是：正数的补码就是其本身；负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
[+1] = [00000001]原 = [00000001]反 = [00000001]补
[-1] = [10000001]原 = [11111110]反 = [11111111]补
对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.
3.8.6 为何要使用原码, 反码和补码
首先, 因为人脑可以知道第一位是符号位, 在计算的时候我们会根据符号位, 选择对真值区域的加减. (真值的概念在本文最开头). 但是对于计算机, 加减乘数已经是最基础的运算, 要设计的尽量简单. 计算机辨别”符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了.
于是人们开始探索 将符号位参与运算, 并且只保留加法的方法. 首先来看原码。计算十进制的表达式: 1-1=0
1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2
如果用原码表示, 让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用原码表示一个数.
为了解决原码做减法的问题, 出现了反码。计算十进制的表达式:
1-1=0
1 - 1 = 1 + (-1)
= [0000 0001]原 + [1000 0001]原
= [0000 0001]反 + [1111 1110]反
= [1111 1111]反 = [1000 0000]原
= -0
发现用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在”0”这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有[0000 0000]原和[1000 0000]原两个编码表示0.
于是补码的出现, 解决了0的符号以及两个编码的问题:
1-1 = 1 + (-1)
= [0000 0001]原 + [1000 0001]原
= [0000 0001]补 + [1111 1111]补
= [0000 0000]补=[0000 0000]原
这样0用[0000 0000]表示, 而以前出现问题的-0则不存在了.而且可以用[1000 0000]表示-128:
(-1) + (-127) = [1000 0001]原 + [1111 1111]原
= [1111 1111]补 + [1000 0001]补
= [1000 0000]补
-1-127的结果应该是-128, 在用补码运算的结果中, [1000 0000]补 就是-128. 但是注意因为实际上是使用以前的-0的补码来表示-128, 所以-128并没有原码和反码表示.(对-128的补码表示[1000 0000]补算出来的原码是[0000 0000]原, 这是不正确的)
使用补码, 不仅仅修复了0的符号以及存在两个编码的问题, 而且还能够多表示一个最低数. 这就是为什么8位二进制, 使用原码或反码表示的范围为[-127, +127], 而使用补码表示的范围为[-128, 127].
3.9 运算符和表达式
Python语言支持以下类型的运算符:
1.算术运算符
2.比较（关系）运算符
3.赋值运算符
4.逻辑运算符
5.位运算符
6. 成员运算符
3.9.1 算术运算符
' + '、' - '、' * '、' / '、' // '（向下取整）、' % '、' ** '
补充：
向上取整:math.ceil()
向下取整math.floor()、//
四舍五入：roud()
>>> a=1
>>> b=2
>>> a+b
3
>>> a-b
-1
>>> a*b
2
>>> a/b
0.5
>>> a//b
0
>>> 11//10
1
>>> 16//10
1
>>> a%b
1
>>> for i in range(11):
... if i%2!=0:
... print(i)
...
1
3
5
7
9
>>> [i for i in range(11) if i%2!=0]
[1, 3, 5, 7, 9]
>>> divmod(10,6)
(1, 4)
>>> divmod(10,6)[0]
1
>>> divmod(10,6)[1]
4
>>> 2**3
8
>>> pow(2,3)
8
>>> import math
>>> math.sqrt(4)
2.0
>>> math.sqrt(2)
1.4142135623730951
>>> abs(-3)
3
>>> math.fabs(-3)
3.0
>>> math.floor(1.999)
1
>>> math.ceil(1.0001)
2
>>> round(4.222)
4
>>>
>>> round(3.56)
43.9.2 比较运算符
== 、!=、>、>=、<、<=
3.9.3 赋值运算符
=、+=、-=、*=、/=、//=、%=
注意：使用赋值运算符效率高一些，减少变量的赋值
| 运算符 |
描述 |
实例 |
| == 等于 |
给左边的变量赋值 |
x= 8 |
| +=加等于 |
左边的变量加上右边的数，再赋值给左边的变量 |
x += 8等价于 x = x + 8 |
| ==减等于 |
左边的变量减去右边的数，再赋值给左边的变量 |
x -= 8等价于 x = x - 8 |
| *=乘等于 |
左边的变量乘以右边的数，再赋值给左边的变量 |
x *= 8等价于 x = x * 8 |
| /=除等于 //=整除等于 |
左边的变量除以右边的变量(整数取整)，再赋值给左边的变量； 左边的变量除以右边的变量取整，再赋值给左边的变量 |
x /= 8 等价于 x = x / 8 x //= 4 等价于x = x // 4 |
| %=求余等于 |
左边的变量除以右边的数取余，再赋值给左边的变量 |
x %= 8等价于 x = x % 8 |
3.9.4 逻辑运算符
and、or、not
3.9.5 位运算符
按位运算符是把数字看着二进制来进行运算
| 符号 |
描述 |
实例 |
| & |
按位与运算符 |
(a & b)输出结果 12，二进制解释：00001100 |
| | |
按位或运算符 |
(a | b)输出结果61，二进制解释：00111101 |
| ^ |
按位异或运算符 |
(a ^ b)输出结果49，二进制解释：00110001 |
| ~ |
按位取反运算符 |
(~a)输出结果-61，二进制解释：11000011 |
>>> a=3
>>> b=5
>>> 3&5
1
>>> 3|5
7
>>> 3^5
6
>>> ~3
-4Python ' ~ ' (取反) 操作符解释
参考《Python的按位取反运算符~》
按位取反运算符，用来对一个二进制数按位取反，即将0变1，将1变0
在计算机系统中，数值一律用补码来表示和存储。
正整数的补码是其二进制表示，与原码相同 。
负整数的补码，将其对应正数二进制表示所有位取反（包括符号位，0变1，1变0）后加1。
实际的计算结果: ~4 = -5, ~-5 = 4
我们的解释思路是,确定正整数的原码=反码=补码===> 取反
(1) 求~4, 我们用二次进制来表示4:
4的原码/反码/补码: 0000 0100
取反得到: 1111 1011, 观察符号位,是负数,因为数值一律以补码存储的,所以问题转化为:
某个数x的补码是1111 1011,求x的值(由补码求原码)
取反: 1000 0100 （符号位不变）
+1: 1000 0101 = -5
(2) 求 ~-5,同理用二进制表示-5:
因为-5是负数, -5的原码1000 0101，-5的反码1111 1010
-5补码: 1111 1011
取反: 0000 0100，观察符号位,是正数
0000 0100 = 4
3.9.6 成员运算符
in、not in
>>> 'a' in "abc"
True
>>> 'a' not in "abc"
False3.9.7 身份运算符
用于比较两个对象的存储单元
| 符号 |
描述 |
| is |
两个标识符引用同一对象（也就是地址相同）就返回 True，否则返回False |
| is not |
两个标识符是否引用不同的对象（也就是地址不一样）就返回 True，否则返回False |
>>> a=1
>>> b=1
>>> a is b
True
>>> id(a)
2436224975088
>>> id(b)
2436224975088
>>> a==b
True
>>> a==3
Falsepython对象的三要素：
- is--判断两个标识符是否引用同一对象，id用来判断对象地址
- type--标识对象类型
- value--是对象的值，用'=='判断的是a对象的值是否等于b对象的值
3.9.8 运算符的优先级
1、一个表达式中，高优先级的先运算
2、同级别的运算符，按从左到右处理
3.9.9 operator包的应用
>>> import operator
>>> print(operator.add(1,1))
2
>>> print(operator.sub(10,3))
7
>>> print(operator.mul(5,4))
20
>>> print(operator.truediv(12,4))
3.0
>>> print(operator.contains("abc","a"))
True
>>> print(operator.pow(3,2))
9
>>> print(operator.ge(1,1))
True
>>> print(operator.ge(2,1))
True
>>> print(operator.le(1,2))
True
>>> print(operator.eq(1,1))
True
>>> help(operator.ge)
Help on built-in function ge in module _operator:
ge(a, b, /)
Same as a >= b.3.10 标准输入、标准输出和错误输出
3.10.1 标准输出
>>> import sys
>>> sys.stdout.write("hello")
hello5
>>> sys.stdout.write("hello"+'\n')
hello
6
>>> len("hello")
5
import sys
print("divein!")
saveout=sys.stdout
fsock=open(r'F:\\python_day2\out.log','w')
sys.stdout=fsock
print("This message will belogged instead of displayed")
sys.stdout=saveout
fsock.close()
"""执行结果：
F:\\python_day2>py -3 demo1.py
divein!
"""3.10.2 标准输入
input()的底层实现是sys.stdin,事实上是先把提示信息输出，然后捕获输入
>>> import sys
>>> hi=sys.stdin.readline()[:-1]
hello
>>> hi
'hello'3.10.3 错误输出
import sys
print("Fatal error:invalid input.",file=open("e:\\log.out","w"))
print("Fatal error:invalid input!",file=sys.stderr)
#运行结果：打印出Fatal error:invalid input!3.10.4 退出程序
import sys
print('1')
sys.exit()
print('2')
3.11 random随机函数
| 方法 |
描述 |
| random.randint(X,Y) |
在[X,Y]闭区间随机取一个整数，其中Y>X是必须条件 |
| random.randrange(X) |
在[0,X)闭开区间内任意随机取值一个正整数，X必须大于0的正整数 |
| random.random( ) |
在（0,1）开区间内任意随机取值一个浮点数 |
| random.uniform(X,Y) |
在[X,Y)闭开区间内任意随机取值一个浮点数，XY大小随意 |
| random.sample(X,6) |
随机在序列X内抽取6个元素组成新的序列 |
| random.choice(X) |
在序列X内任意随机取一个元素 |
| random.shuffle(X) |
打乱序列X的元素排序 |
>>> import random
>>> random.random()
0.7596468085631344
>>> random.random()
0.2952145577615418
>>> random.randint(1,2)
2
>>> random.randint(1,2)
1
>>> random.randint(1,100)
81
>>> a=list(range(10))
>>> random.shuffle(a)
>>> a
[3, 2, 5, 9, 1, 8, 7, 0, 4, 6]
>>> random.shuffle(a)
>>> a
[7, 0, 8, 6, 2, 5, 3, 1, 9, 4]
>>> random.uniform(1,100)
95.27550603840659
>>> s="abcdefg"
>>> random.choice(s)
'a'
>>> random.choice(s)
'e'
>>> random.sample(s,3)
['e', 'a', 'f']3.12 浮点数计算之坑
浮点运算无法得出精确地计算结果，可用整型数计算（整型计算是精确的）。比如在保留两位小数的计算中，可以把原始数乘以100取整数再计算，约定最后两位为小数即可
>>> 10-9.9
0.09999999999999964
>>> 123.3-100
23.299999999999997
>>> (10*10-9.9*10)/10
0.1
>>> (123.3*10-100*10)/10
23.33.12.1 decimal模块
>>> import decimal
>>> from decimal import Decimal, getcontext
>>> getcontext().prec = 9
>>> r1 = Decimal(1) / Decimal(3)
>>> print("r1 ", r1)
r1 0.333333333
2.但是getcontext().prec会包含小数点前面的所有长度（小数大于1.0时），当 前面长度有变化时并不能固定控制小数点后的位数
>>> r2 = Decimal(10) / Decimal(3)
>>> print("r2 ", r2)
r2 3.333333333.想要固定控制小数点后面的位数则需要使用decimal.quantize(Decimal('0.00000000'))，注意不能超过getcontext().prec的位数
>>> r3 = Decimal(1) / Decimal(3)
>>> print("r3 ", r3.quantize(Decimal('0.00000000')))
r3 0.33333333
>>> r4 = Decimal(10) / Decimal(3)
>>> print("r4 ", r4.quantize(Decimal('0.00000000')))
r4 3.33333333
>>> r5 = Decimal(10) / Decimal(str(1.5))
>>> print("r5 ", r5.quantize(Decimal('0.00000000')))
r5 6.666666674.向上取整
getcontext().rounding = getattr(decimal, 'ROUND_CEILING') # 总是趋向无穷大向上取整
>>> r6 = Decimal(10) / Decimal(str(1.5))
>>> print("r6 ", r6.quantize(Decimal('0.00000000')))
r6 6.66666667
>>> r7 = Decimal(10) / Decimal(3)
>>> print("r7 ", r7.quantize(Decimal('0.00000000')))
r7 3.333333335.向下取整
getcontext().rounding = getattr(decimal, 'ROUND_FLOOR') # 总是趋向无穷大向下取整
>>> r8 = Decimal(10) / Decimal(str(1.5))
>>> print("r8 ", r8.quantize(Decimal('0.00000000')))
r8 6.66666667
>>> r9 = Decimal(10) / Decimal(3)
>>> print("r9 ", r9.quantize(Decimal('0.00000000')))
r9 3.33333333四、课堂练习题
4.1 输入两个数，判断两个数是正数还是负数
#encoding=utf-8
num1 = int(input("请输入第一个数字:"))
num2 = int(input("请输入第二个数字:"))
if num1 > 0 and num2 > 0:
print("两个数字都是正数")
elif num1 < 0 and num2 < 0:
print("两个数字都是负数")
elif (num1 < 0 and num2 > 0) or (num1 > 0 and num2 < 0):
print("一正一负")
elif num1 == 0 and num2 == 0:
print("都是0")
elif (num1 == 0 and num2 != 0) or (num1 != 0 and num2 == 0):
print("一0一非0")4.2 找到列表中最大和第二大的值
#num_list=[1,2,3,4,5,5,6,4]
#num_list=[7,6,3,7,5,5,6,4]
num_list=[7,6,3,7,13,10,6,4]
max_num=""
second_max_num=""
for i in num_list:
print("i=",i)
if max_num == "":
max_num = i
print(1)
elif i > max_num:
second_max_num = max_num
max_num = i
print(2)
elif i < max_num and second_max_num == "":
second_max_num = i
print(3)
elif i < max_num and i > second_max_num:
second_max_num = i
print(4)
print("*"*20)
print("最大值:",max_num)
print("第二大值:",second_max_num)
"""
方法2：使用python自带函数
"""
num_list=[7,6,3,7,13,10,6,4]
result = sorted(list(set(num_list)))
print("最大值:",result[-1])
print("第二大值:",result[-2])4.3 随机生成一个10位数字；随机生成一个10位字母
import random
>>> str(random.randint(1000000000,9999999999))
'6317115872'
>>> a=[0,1,2,3,4,5,6,7,8,9]
>>> result = ""
>>> for i in range(10):
... result += str(random.choice(a))
...
>>> result
'9025682376'
>>> import string
>>> random.sample(string.ascii_letters,10)
['b', 'K', 'P', 'H', 'G', 'c', 'u', 'W', 'M', 'k']
>>> "".join(random.sample(string.ascii_letters,10))
'LfsRdMVgEi'4.4 生成3个数字、3个小写字母、3个大写字母
import random
num_part = str(random.randint(100,999))
lower_letter_part = ""
for i in range(3):
lower_letter_part += chr(random.randint(97,122))
upper_letter_part = ""
for i in range(3):
upper_letter_part += chr(random.randint(65,90))
result = list(num_part + lower_letter_part + upper_letter_part)
random.shuffle(result)
print("".join(result))4.5 二进制与十进制互转
二进制转十进制
bin_str="1101"
bin_len=len(bin_str)
result=0
for i in range(bin_len):
result += int(bin_str[i])*2**(bin_len-1-i)
print(result)
十进制转二进制
num=789
result=""
while num:
result+=str(divmod(num,2)[1])
num=divmod(num,2)[0]
#result+=str(divmod(num,2)[1])
print(result[::-1])
"""
方法2
"""
num=789
result=[]
while num!=0:
num, num2=divmod(num,2)
result.insert(0,str(num2))
print("".join(result))