>>> s="中国"    # Unicode类型（默认类型），可以用于计算机内存中，不能用于文件存储和网络传输
>>> type(s)
<class 'str'>
>>> s=s.encode("utf-8") # 编码成bytes类型，可用于文件存储和网络传输
>>> type(s)
<class 'bytes'>
>>> s
b'\xe4\xb8\xad\xe5\x9b\xbd'
>>> s+"中国"
Traceback (most recent call last):File "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
AttributeError: 'bytes' object has no attribute 'encode'. Did you mean: 'decode'?
>>> s.decode("utf-8")
'中国'

解决py文件中文乱码的问题：
1、把程序文件，保存为utf-8编码
2、程序文件头不声明编码，或者声明#encoding=utf-8

C:\Users\asus>pip install chardet
Collecting chardetDownloading 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)
False

>>> bin(0b111)
'0b111'
>>> bin(111)
'0b1101111'
>>> bin(0o11)
'0b1001'
>>> bin(0xA1)
'0b10100001'
>>> type(bin)
<class 'builtin_function_or_method'>

>>> type(oct)
<class 'builtin_function_or_method'>
>>> oct(0b1111)
'0o17'
>>> oct(0o167)
'0o167'
>>> oct(16)
'0o20'
>>> oct(0xFFF)
'0o7777'

>>> type(hex)
<class 'builtin_function_or_method'>
>>> hex(0b1001)
'0x9'
>>> hex(16)
'0x10'
>>> hex(15)
'0xf'
>>> hex(0o100)
'0x40'
>>> hex(0xAF11)
'0xaf11'

>>> 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 "<stdin>", line 1, in <module>
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))
<class 'str'>
>>> 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基础

>>> 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 数据类型和变量

# -*-coding:utf-8-*-
# Filename:const.py
# 定义一个常量类实现常量的功能
"""
该类定义了一个方法__setattr()__,和一个异常ConstError,ConstError类继承自类TypeError。
通过调用类自带的字典__dict__，判断定义的常量是否包含在字典中。
如果字典中包含此变量，将抛出异常，否则，给新创建的常量赋值。
最后两行代码的作用是把const类注册到sys.modules这个全局字典中。
"""
class _const:class ConstError(TypeError):passdef __setattr__(self,name,value):if name in self.__dict__:raise self.ConstErrorself.__dict__[name]=valueimport sys
sys.modules[__name__]=_const()
print(__name__)# test_const.py
# 测试const类
import const
const.magic = 23
print(const.magic)
const.magic = 33C:\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 <module>const.magic = 33File "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)
True

3.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 变量

变量名命名规则：

>>> 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
<stdin>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
False
>>> a=2
>>> a is 2
<stdin>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
True
>>> a=257
>>> a is 257
<stdin>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
False
>>> id(a)
2436226013392
>>> id(257)
2436226013712
>>> a=256
>>> a is 256
<stdin>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
True
>>> id(a)
2436224983248
>>> id(256)
2436224983248

3.5 保留字

3.6 物理行和逻辑行

物理行：文件中的一行

>>> s="这是第一行前半段\
...  ,这是第一行得后半段"
>>> s
'这是第一行前半段 ,这是第一行得后半段'
>>> print("hello");print(" line");print("world!")
helloline
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)
4

3.9.2 比较运算符

== 、!=、>、>=、<、<=

3.9.3 赋值运算符

=、+=、-=、*=、/=、//=、%=

注意：使用赋值运算符效率高一些，减少变量的赋值

3.9.4 逻辑运算符

and、or、not

3.9.5 位运算符

按位运算符是把数字看着二进制来进行运算

>>> a=3
>>> b=5
>>> 3&5
1
>>> 3|5
7
>>> 3^5
6
>>> ~3
-4

Python ' ~ ' (取反) 操作符解释

参考《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"
False

3.9.7 身份运算符

用于比较两个对象的存储单元

>>> a=1
>>> b=1
>>> a is b
True
>>> id(a)
2436224975088
>>> id(b)
2436224975088
>>> a==b
True
>>> a==3
False

python对象的三要素：

1. is--判断两个标识符是否引用同一对象，id用来判断对象地址
2. type--标识对象类型
3. 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")
5import 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随机函数

>>> 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.3

3.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.33333333

3.想要固定控制小数点后面的位数则需要使用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.66666667

4.向上取整

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.33333333

5.向下取整

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 = iprint(1)elif i > max_num:second_max_num = max_nummax_num = iprint(2)elif i < max_num and second_max_num == "":second_max_num = iprint(3)elif i < max_num and i > second_max_num:second_max_num = iprint(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))