Python基础数据类型

数据类型

Python中能直接处理的基础数据类型包含数值（整数、浮点数、复数）、字符串、布尔值、空值。
此外还包括列表、元组、集合、字典、自定义数据类型等较为复杂的数据类型。

数值

在Python中所有的整数都是int类型，Python中的整数的大小没有限制，可以是一个无限大的整数
所有的小数都是float类型，对浮点数进行运算时，可能会得到一个不精确的结果。进行数值计算的
时候，python可以作为科学计算器，且数值的大小范围无限制

如果数字的长度过大，可以使用下划线作为分隔符   
c = 123_456_789
10进制的数字不能以0开头  
d = 0123 （ × 运行会报错）  

进制：计算机一般使用二进制进行运算和数据的存储，有时16进制表示数据更加方便，所以计算机
也使用16进制来表示数据。10进制对人是友善的。其他进制的整数，只要是数字打印时一定是以十
进制的形式显示的。

进制数：
    二进制 0b开头  
    num = 0b10   #代表10
    八进制 0o开头    
    num = 0o10   #代表8
    十六进制 0x开头  
    num = 0x10   #代表16

通过运算符可以对数字进行运算，并且可以保证整数运算的精确，当然浮点数的误差无法避免

整数

整数指代的就是数学中的整数：
        正数    45、300
整数     零     0
        负数    -1、-100

浮点数

小数就是浮点数，浮点数的小数点位置是可变的，
    比如，1.23x109和12.3x108是完全相等的。
    · 浮点数可以用数学写法，如1.23，3.14，-9.01，等等。也可以用科学计数法表示，把10用e替代，
1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
    · 整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？
是的！），而浮点数运算则可能会有四舍五入的误差。

复数

复数是在复数域中使用的数值，超出了实数的范围，与实数并列。
            实数  -1、0、30
    数  
            复数   2+3j、1-2j、-1-1j

复数的序数单位不再是i而是j，虚部如果是1也不能省略，否者报错。

计算：

我们可以通过数学表达式或者是Python的内置函数来进行数值计算。

#内置函数计算
abs(x)
#绝对值（absolute）
# 返回一个数的绝对值。 参数可以是一个整数或浮点数。 如果参数是复数，则返回它的模。
# 请先忽略本句： 如果 x 定义了 __abs__()，则 abs(x) 将返回 x.__abs__()。
print(abs(1+1j))#1.4142135623730951

max(arg1, arg2, *args[, key])
# 返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
a = 30
b = 40
c = 10
print(max(a,b,c))#40
list = [20,30,10,20]
print(max(list))#30

min(arg1, arg2, *args[, key])
# 返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
min函数的用法类同于max，只是返回的值是最小值。

sum(iterable, /, start=0)
# 从 start 开始自左向右对 iterable(可迭代) 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。
list = [1,2,3,4]
sum(list)#10

Python运算符

运算符可以对一个值或多个值进行运算或各种操作

运算符的分类：  
    1.算术运算符  
    2.赋值运算符  
    3.比较运算符（关系运算符）  
    4.逻辑运算符  
    5.条件运算符（三元运算符）

• 算术运算符

   +   加法运算符（字符串：进行拼串操作）    
   —   减法运算符    
   *   乘法运算符（字符串和数字相乘，就会将字符串重复指定次数）  
   /   除法运算符，运算时结果总会返回一个浮点类型  
   //  整除，保留计算后的整数位并返回
   **  幂运算，求幂运算  
   %   取模，求两个数相除的模
  

• 赋值运算符=

    等号右侧的值赋值给等号左侧的变量  
    简写规则：   
        +=
            a += 5   相当于 a = a + 5  
        -=
            a -= 5   相当于 a = a - 5   
        *= 
            a *= 5   相当于 a = a * 5
        **=      
            a **= 5  相当于 a = a ** 5   
        /=
            a /= 5   相当于 a = a / 5   
        //=   
            a //= 5  相当于 a = a // 5   
        %=   
            a %= 5   相当于 a = a % 5   
  

• 关系运算符

关系运算符用来比较两个值之间的关系，总会返回一个布尔值；如果成立，返回True，否则返回False

>       比较左侧值是否大于右侧值  
>=      比较左侧的值是否大于或等于右侧的值  
<       比较左侧值是否小于右侧值  
<=      比较左侧的值是否小于或等于右侧的值  
==      比较两个对象的值是否相等  
!=      比较两个对象的值是否不相等（ 相等和不等比较的是对象的值，而不是id ）       
is      比较两个对象是否是同一个对象，比较的是对象的id  
is not  比较两个对象是否不是同一个对象，比较的是对象的id   

补充：在Python中可以对两个字符串进行大于（等于）或小于（等于）的运算`
    * 当对字符串进行比较时，实际上比较的是字符串的Unicode编码  
    * 比较两个字符串的Unicode编码时，是逐位比较的  
    * 利用该特性可以对字符串按照字母顺序进行排序    

注意：如果不希望比较两个字符串的Unicode编码，则需要将其转换为数字（`int()`）然后再比较

• 逻辑运算符

逻辑运算符主要用来做一些逻辑判断

not 逻辑非  可以对符号右侧的值进行非运算
    - 对于布尔值，非运算会对其进行取反操作，True变False，False变True
    - 对于非布尔值，非运算会先将其转换为布尔值，然后再取反  

and 逻辑与  可以对符号两侧的值进行与运算,与运算是找False的
    只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False
Python中的与运算是短路的与，如果第一个值为False，则不再看第二个值

or 逻辑或  可以对符号两侧的值进行或运算,或运算是找True的
    或运算两个值中只要有一个True，就会返回True
Python中的或运算是短路的或，如果第一个值为True，则不再看第二个值

• 非布尔值的与或运算

当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值

>>> a = 1 and 2
>>> a
2
>>> a = 1 or 2
>>> a
1

* 与运算的规则  
    - 与运算是找False的，如果第一个值是False，则不看第二个值  
    - 如果第一个值是False，则直接返回第一个值，否则返回第二个值
* 或运算的规则  
    - 或运算是找True的，如果第一个值是True，则不看第二个值  
    - 如果第一个值是True，则直接返回第一个值，否则返回第二个值   

• 条件运算符（三元运算符）
  语法： 语句1 if 条件表达式 else 语句2

条件运算符在执行时，会先对条件表达式进行求值判断
- 如果判断结果为True，则执行语句1，并返回执行结果
- 如果判断结果为False，则执行语句2，并返回执行结果

#获取a和b之间的较大值
max = a if a > b else b
print(max)

运算符的优先级

和数学中一样，在Python运算也有优先级，比如先乘除,后加减。运算符的优先级可以根据优先级的表格来查询。在表格中位置越靠下的运算符优先级越高，优先级越高的越优先计算,如果优先级一样则自左向右计算。

在开发中如果遇到优先级不清楚的,则可以通过小括号来改变运算顺序。

注意：  
    * and（与）的优先级高于 or（或）  
    * 逻辑运算符可以连着使用
        result = 1 < 2 < 3 # 相当于 1 < 2 and 2 < 3
        需要注意是对于中间数进行比较

字符串

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果’本身也是一个字符，那就可以用""括起来，比如"I'm OK"

长字符串

• 单引号和双引号不能跨行使用,可以使用\来达到跨行的目的

    s = '锄禾日当午，\  
    汗滴禾下土，\  
    谁知盘中餐，\  
    粒粒皆辛苦'    
    输出：锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦  
  

• 使用三重引号来表示一个长字符串（ '''或""" ）

    三重引号可以换行，并且会保留字符串中的格式  
        s = '''锄禾日当午，  
        汗滴禾下土，  
        谁知盘中餐，  
        粒粒皆辛苦'''  
        输出：   
        锄禾日当午，  
        汗滴禾下土，  
        谁知盘中餐，  
        粒粒皆辛苦            
  

---

转义字符

• 可以使用 \ 作为转义字符；通过转义字符，可以在字符串中使用一些特殊的内容

  例子：  
    \' 表示 ' (就是'号) 
    \" 表示 " (就是"号)
    \t 表示制表符  
    \n 表示换行符  
    \\ 表示 \ (反斜杠) 
    \uxxxx 表示Unicode编码  
    
    s = '\u2250'  
    print(s) # ≐
    s = '\"你好\"'   
    print(s) # ”你好“  
  

---

格式化字符串

• 字符串间进行加法运算，会自动将两个字符串拼接为一个

    a = 'abc' + '123'   
    print(a)# abc1232   
    字符串不能和其他的类型进行加法运算，如果做了会出现异常 TypeError: must be str, not int   
  

• 在创建字符串时，可以在字符串中指定占位符

    %s 字符串占位符            b = 'Hello %s'%'你好'       eg:hello 你好
    %f 浮点数占位符            b = 'hello %.2f'%123.456    eg:hello 123.45  （默认则输出小数点后六位）
    %d 整数占位符              b = 'hello %d'%123.95       eg:hello 123
    
    -当有多个占位符时，可以使用括号（）来将待输出量括起来
    print("%d\n%.3f\n%s\n%s\n%s\n%s" % (n, f, s1, s2, s3, s4))
    特殊格式简介：
            %3s    意味着：字符串最小长度为3，不足用空格左补齐
            %3.5s  意味着：字符串的长度限制在3-5之间
            %.2f   意味着：小数点后保留两位小数
  

• 通过在字符串前添加一个f来创建一个格式化字符串；在格式化字符串中可以直接嵌入变量

    a = 'boy'   
    b = '132'   
    c = f'love{a}{b}'  
    print(c)  
    输出：loveboy132  
    print(f'str = {c}')  
    输出：str = loveboy132  
  

• 可以使用*来复制字符串

    >>> a = '12ds'
    >>> a = a*3
    >>> a
        '12ds12ds12ds'
  

布尔值（bool）和空值（None）

布尔值一共有两个 True 和 False，True表示真 False表示假

bool	类型	值
ture	int	1
false	int	0

布尔值可以看作整型，True就相当于1，False就相当于0

布尔值可以用and、or和not运算

and运算是与运算，只有所有都为True，and运算结果才是True
or运算是或运算，只要其中有一个为True，or运算结果就是True
not运算是非运算，它是一个单目运算符，把True变成False，False变成True

布尔值经常用在条件判断句中

if age >= 18:
print('adult')
else:
print('teenager')   

空值None：专门用来表示不存在，空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值

类型检查

通过类型检查函数 type()，可以检查变量的类型

print(type(b))
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello'))  # <class 'str'>
print(type(None)) # <class 'NoneType'>