Python学习笔记一：01数值类型以及数据类型

isinstance 和 type 的区别在于：

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

区别就是:

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

（1）int整型

>>>type(1)　　#查看类型  int整型 结果为 <class 'int'>

>>>a=1

>>>type(a)

（2）float浮点型

浮点型由整数部分和小数部分组成，也可以使用科学计数法表示

>>>type(1.1)　　#查看类型  int整型 结果为 <class 'float'>

>>>a=1.1

>>>type(a)

>>>a-1　　#0.10000000000009

>>>import decimal　　#十进制的浮点型

>>>d=decimal.Decimal('1.1')

>>>d-a　　#0.1

 (3)布尔型

>>>c=True　　 #bool 值为1 橙色为关键字 得大写
>>>type(c)
>>>c2=False 　　 #值为0 可以数字相加
>>>type(c2)

（4）复数型

可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

>>>e=1+2j 　　#只能用j或者J表示虚部
>>>type(e)　　 #complex型

1.1补充：

(1)基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

(2)多个变量赋值

Python允许你同时为多个变量赋值。例如：

>>>a = b = c = 1　　#创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：

>>>a, b, c = 1, 2, "runoob"　　#两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。
>>>a=1;b=2　　#两个整型对象1和2的分配给a和b

（3）查看属性方法

>>>dir(__builtins__) #查看属性方法

（4）查看所有关键字

  ①>>>import keyword 　　#导入关键字模块

　>>>keyword.kwlist 　　#调用属性

  ②>>>help('keywords')     #基础阶段重要的内置函数 查看关键字

（5）保存及运行文件

①IDLE中file→new file

　　file→save(ctrl+s) 在弹窗中选择路径和填写文件名

②Run→Run Moudle(F5) 即可在IDLE中运行

（6）默认颜色说明

  紫色为内置函数，例如dir,print,type,int,list,tuple,print

  橙色为关键字，例如True

（7）使用del语句删除一些对象引用

　可以通过使用del语句删除单个或多个对象。例如：

>>>del var

>>>del var_a,var_b

2.数值运算

python支持以下七种运算符：

　　（1）算术运算符

　　（2）比较（关系）运算符

　　（3）赋值运算符

　　（4）逻辑运算符

　　（5）位运算符

　　（6）成员运算符

　　（7）身份运算符

（1）算术运算符

　　+ 　　-　　 * 　　/（数值的除法的结果是浮点数）　　//（整除，向下取整，地板除法）　　%（取余）　　x**y（返回x的y次幂）

>>>q=5;w=2

>>>q//w #2 向下取整

>>>q/w #2.5

>>>a,b=9.0,2.0

>>>a//b=4.0

>>>import math　　#导入数学模块

>>>math.ceil(5/2) #3 向上取整

>>>dir(math)　　#查看math的方法

>>>5%2 #取余运算 为1

>>>2**4 #幂运算 2的4次方为16

（2）比较运算符

假设变量a为10，b为20

==	等于	(a==b)返回False
！=	不等于	(a!=b)返回Ture
>	大于	(a>b)返回False
<	小于	(a<b)返回Ture
>=	大于等于	(a>=b)返回False
<=	小于等于	(a<=b)返回Ture

 

 

 

 

 

 

 

 

（3）赋值运算符

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

>>>a+=1　　#等价于a=a+1
（在混合计算时，Python会把整型转换成为浮点数。）

（4）位运算符

　　位运算符是把数字看作二进制进行计算的。

假设a为60，b为13

a:0011 1100　　b:0000 1101

&	按位与运算符：若参与运算的两个值的两个相应位都为1，则该位的结果为1，否则为0	(a&b)输出结果12，二进制解释：0000 1100
|	按位或运算符：只要对应的两个二进制位有一个为1，结果位就为1	(a|b)输出结果60，二进制解释：0011 1101
^	按位异或运算符：当两个对应的二进制位相异时，结果为1	(a^b)输出结果49，二进制解释：0011 0001
~	按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1	(a~b)输出结果-61，二进制解释：1100 0011
<<	左移动运算符：运算数的各个二进制位全部左移若干位，由<<<右边的数指定移动的位数，高位丢弃，低位补0	(a<<2)输出结果240，二进制解释：1111 0000
>>	右移动运算符：运算数的各个二进制位全部右移若干位，由<<<右边的数指定移动的位数	(a>>2)输出结果15，二进制解释：0000 1111

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

(5)逻辑运算符

假设a为10，b为20

and	布尔“与”：如果x为False，x and y就返回False，否则返回y的计算值	(a and b)返回20
or	布尔“或”：如果是非0，就返回x的值，否则返回y的计算值	(a or b)返回10
not	布尔“非”：如果x为True，就返回False，如果x为False，就返回True	not(a and b)返回False

 

 

 

 

 

 

 

(6)成员运算符

假设a为10，list=[1,2,3,4,5]

in	如果在指定的序列中找到值，就返回True，否则返回False	print(a in list)返回False
not in	如果在指定的序列中没有找到值，就返回True，否则就返回False	print(a not in list)返回True

 

 

 

 

 

(7)身份运算符

假设a为10，b为10

is	is判断两个标识符是否引用自同一个对象	print(a is b)返回True
not is	is not 用来判断两个标识符是否引用自不同对象	print(a not is b)返回False

 

 

 

 

2.1运算符优先级

表中列出了从最高到最低优先级的所有运算符

**	指数（最高级）
~、+、-	按位翻转、一元加号和减号
*、/、%、//	乘、除、取模、取整除
+、-	加法、减法
>>、<<	右移、左移运算符
&	位与
^、|	位运算符
<=、<、>、>=	比较运算符
<>、==、!=	等于运算符
=、&=、/=、//=、-=、+=、*=、**=	赋值运算符
Is、is not	身份运算符
In、not in	成员运算符
not、or、and	逻辑运算符

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

注意：

　　（1）括号拥有最高优先级，可以强制表达式按照需要的顺序求值

　　（2）乘方拥有次高的优先级

　　（3）优先级相同的操作按照自左向右的顺序求值（乘方除外）

 

3.序列类型

　在python中有三种序列类型，序列类型简单来说就是对象里面的元素是有顺序的

   #Python包含6种内建序列,即列表、元组、字符串、Unicode字符串、buffer字符串、xrange对象

• 字符串　　str
• 列表　　list
• 元组　　tuple

    其中

• 可变序列　　list
• 不可变序列　　tuple,str

（1）字符串  str

①创建

   Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。

>>>s1='asljf123'     #'asljf123'

>>>s2='asljf' '123'  #'asljf123'

>>>s3="asd:'adffw'" #"asd:'adffw'"  引用谁说的话

>>>s4='''aaa　　　　#可以跨行

>>>ggg'''　　　　#'aaa\ngggg'

②操作

   字符串是不可变的，所以字符串做不了分片赋值

  Ⅰ. 加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。

>>>str = 'Runoob'

>>>print (str * 2) # 输出字符串两次  RunoobRunoob

>>>print (str + "TEST") # 连接字符串  RunoobTEST

  Ⅱ.Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r或者添加一个\，表示原始字符串：

>>> print('Ru\noob')  #Ru   此处有换行     oob

>>>print('Ru\\noob')　　#Ru\noob

>>> print(r'Ru\noob')  #Ru\noob

  Ⅲ.另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

注意：Python 没有单独的字符类型即没有char，一个字符就是长度为1的字符串。

　　    与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0]='m'会导致错误。

（2）列表  list

　　列表的内容是可变的
①创建
　　List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。列表是写在方括号([])之间、用逗号分隔开的元素列表。列表中的元素类型也可以不相同。

>>>list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]

>>>li=['a','b']  #list 写在方括号之间，元素用逗号隔开

②操作

　　与Python字符串不一样的是，列表中的元素是可以改变的：

　　1.元素赋值

　　>>>a = [1, 2, 3, 4, 5, 6]

　　>>> a[0] = 9　　　　#变为了a=[9,2,3,4,5,6]

　　>>>a [1]='hello' 　　#[1, 'hello', 3, 4, 5, 6]

　　>>> a[2:5] = []           # 将对应的元素值设置为 []  变为了[9, 2, 6]　　

　　可以对一个列表中的元素赋不同类型的值。列表a中既有int类型的值，也有str类型的值。

　　不能对一个不存在元素的位置赋值。

　　2.增加元素

　　append()方法是一个用于在列表末尾添加新对象的方法。该方法的语法如下：

　　list.append(obj)

　　append()方法不是简单地返回一个修改过的新列表，而是直接修改原来的列表。

　　>>>a.append('ww')　　#a = [1, 2, 3, 4, 5, 6,'ww']

　　3.删除元素

　　可以使用del删除元素

　　>>>del a[1]　　　　#a = [1, 3, 4, 5, 6,'ww']

　　4.分片赋值

　　>>>show=('hi,boy')

　　>>>show[3:]=list('man')　　#['h', 'i', ',', 'm', 'a', 'n']

　　这里运用了list()强制类型转换

　　>>>greeting=list('hi')

　　>>>greeting=list[1:]=list('hello')　　#['h','e','l','l','o']

　　这就是分片赋值另一个强大的功能，可以使用与原序列不能长的序列将分片替换

　　>>>field=list('ae')

　　>>>field[1:1]=list('bcd')　　#['a', 'b', 'c', 'd', 'e']

　　可以在不替换任何原有元素的情况下在任意位置插入新元素。

　　>>>field1=list('abcde')

　　>>>field1[1:4]=[]　　　　#['a','e']

　　使用了前面插入操作的逆操作，可以对序列中任意位置的元素进行删除

　　>>>field2=['a','b','c']

　　>>>num=[1,2,3]

　　>>>mix=[field2,num]

　　>>>mix[0]　　#['a','b','c']

　　>>>mix[0][0]　　#'a'

　　在列表中可以嵌套列表

（3）元组  tuple

　　元组与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。元组中的元素类型也可以不相同。

　　因为元组不可变，所以代码更安全，如果可能，能用元组代替列表就尽量用元组

①创建

>>>tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )

>>>tu=(1,2,3) 　　#tuple

>>>tu=1,2,3 　　 #也是元组

>>>tu=1　　 #变为整型了 tu=(1)

>>>tu=(1,)　　 #所以得用逗号区分，只有一个元素的时候要加逗号

>>>tup1 = ()    # 空元组

　访问元组：使用下标索引访问

　修改元组：元组中的元素值不允许修改，但可以对元组进行连接组合

　删除元组：元组中的元素值不允许删除，但可以使用del语句删除整个元组

　元组截取：用索引截取一段元素

4.序列的通用操作  

  Python中所有序列都可以进行一些特定操作，包括索引、分片、序列相加、乘法、成员资格、长度、最小值和最大值。

  索引 步长　　（都有正负之分）

　　4.1　　索引

　　序列中的每个元素都分配一个数字，代表它在序列中的位置（索引），第一个索引为0，第二个是1，以此类推，-1为末尾的开始位置。

　　序列中可以通过编号分别对序列的元素进行访问。

　　>>>greeting='Hello'

　　>>>greeting[0]   #H

　　>>>greeting[1]   #e

　　>>>greeting[-1]  #o

　　获取元素的方式为：在变量后加中括号[]，在中括号中输入所取元素的索引（编号值）。

　　字符串是由字符组成的序列，索引0指向第一个元素。

　　在Python中，从左向右索引称为正数索引，从右向左索引称为负数索引。

　　>>>'Hello'[0]

　　直接使用索引，不定义变量进行引用也可以。

　　>>>thirdt=input()[0]   

　　直接队函数的返回结果进行了索引操作。

　　索引既可以对变量的引用操作，也可以直接操作序列，还可以操作函数的返回序列。

　　当索引超出范围时，Python会报一个IndexError错误，即索引越界错误。要确保索引不越界，记得最后一个元素的索引是len(str)-1

4.2　　分片

　　索引用来对单个元素进行访问，使用分片可以对一定范围内的元素进行访问，分片通过冒号相隔的两个索引实现。

　　序列的截取（序列被截取后返回一个包含所需元素的新序列。）的语法格式如下：

　　　　变量[头下标:尾下标]

　　>>>li=['a','b','c','d','e']

　　>>>len(li)  #计算长度

　　>>>li[3]  #为'd'

　　>>>tu=(1,2,3,4,5)

　　>>>tu[3]    #为4，输出第三个元素

　　>>>li[0:3]  #为['a', 'b', 'c'] 切片 左闭右开的

　　>>>li[2:]   #['c', 'd', 'e'] 输出从第三个元素开始的所有元素

　　>>>li[:]    #['a', 'b', 'c', 'd', 'e'] 全部

　　分片操作既支持正数索引，也支持负数索引。　　

　　分片操作的实现需要提供两个索引作为边界，第一个索引的元素包含在分片内，第二个索引的元素不包含在分片内，即左闭右开。

　　>>>li[-3:0]   #[]

　　只要在分片中最左边的索引比它右边的索引晚出现在序列中，结果就是一个空序列。

　　>>>number[-100:-1]　　#[1, 2, 3, 4, 5, 6, 7, 8, 9]

　　分片操作不存在索引越界的问题，分片操作对不存在的编号返回空值，存在的就返回对应值。

　　4.2.1　　步长

　　进行分片时，分片的开始和结束点都需要指定（无论是直接还是间接），用这种方式取连续的元素没有问题，但若要取序列中不连续的元素就比较麻烦，

　　或者直接不能操作。所以，Python提供了另一个参数--步长，该参数通常是隐式设置的。在普通分片中，步长是1，步长不能为0.

　　分片操作就是按照这个步长逐个遍历序列的元素，遍历后返回开始和结束点之间的所有元素。

　　>>>number=[1,2,3,4,5,6,7,8,9,10]

　　>>>number[0:10:2]　　#[1,3,5,7,9]  设置步长为2时，得到奇数序列，其中这个2就是步长的显示设置

　　>>>li[::]   #['a', 'b', 'c', 'd', 'e'] 第二个：后为步长 默认为1

　　>>>li[::2]  #['a', 'c', 'e'] 两个走一步　　

　　使用负数步长

　　>>>li[5:0:-1]  #['e', 'd', 'c', 'b']

　　>>>li[0:5:-1]  #[]  拿不到东西

　　>>>li[-1:-6:-1]  #['e', 'd', 'c', 'b', 'a']

　　>>>li[-3:-5:-1]  #['c', 'b']

　　>>>li[5:0:-1]  #['e', 'd', 'c', 'b']  #设置第二个索引为0，取不到序列中的第一个元素

　　>>>li[5::-1]  #['e', 'd', 'c', 'b', 'a']　　#设置第二个索引为空，可以取到序列的第一个元素

　　对于正数步长，Python会从序列的头部开始向右提取元素，直到最后一个元素；

　　对于负数步长，则是从序列的尾部开始向左提取元素，直到第一个元素。

　　正数步长必须让开始点小于结束点，而负数步长必须让开始点大于结束点。

　　4.3　　序列相加

　　使用加号可以进行序列的连续操作。

　　>>>[1,2,4]+[4,5,6]　　#[1,2,4,4,5,6]

　　>>>'sssdd'+'qqqeee'　　#'sssddqqqeee'

　　只有类型相同的序列才能通过加号进行序列连接操作，不同类型的序列不能通过加号进行序列连接操作。

　　4.4　　乘法

　　用一个数字x乘以一个序列会生成新的序列。在新的序列中，原来的序列将被重复x次，这就是序列中的乘法。

　　>>>‘h'*5　　#'hhhhh'

　　>>>[1]*3　　#[1,1,1]

　　如果要创建一个重复序列，就可以像上面的示例一样乘以一个想要得到的序列长度的数字，这样就可以快速得到需要的列表，非常方便。

　　空列表可以简单通过两个中括号[]表示，表示里面什么东西都没有。如果创建一个占用10个或更多元素的空间，却不包括任何有用内容的列表。

　　如果要初始化一个长度为x的序列，就需要让每个编码位置上都是空值，此时使用None代表空值。None是Python的內建值。

　　>>>sq=[None]*5　　#[None, None, None, None, None]　　初始化sq为含有5个None的序列

　　4.5　　成员资格

　　　in和not in

　　in运算符用于检验某个条件是否为真，并返回检验结果，真为True，假为False。这种运算符称作布尔运算符，返回的值叫布尔值。

　　>>>li='lucky' 

　　>>>'lucky' in li #Ture 

　　>>>'lucky' not in #False

　　>>>number=[1,2,3,4,5]

　　>>>'a' in number　　#False

　　>>>3 in li #报错

　　数字类型不能在字符串类型中通过in进行成员资格检测，而字符串类型可以在数字列表中通过in进行成员资格检测。

　　4.6　　长度、最小值和最大值

　　对应的内建函数分别是len、max和min

　　>>>len(number)　　#5

　　>>>max(1,1,2,3,4)　　#4

　　max和min函数的参数可以是多个数字直接作为参数。

（3）数据类型的转换

　　有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

>>>a=int(1.1) 　　#a为1

>>>list('abc') 　　#['a', 'b', 'c']

5.变量命名规则

　　变量命名由字母，数字，下划线组成。不能以数字开头。不能用关键字。

>>>import keyword

>>>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']

6.编码来源

　　由于计算机最早是美国人发明的，因此最早只有127个字母被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码

　　要处理中文，显然一个字节是不够的，至少需要两个字节，而且不能和ASCII编码冲突，所以中国指定了GB2312编码，用来把中文编进去

　　所以各国有各国的标准，Unicode把所有语言都统一到一套编码里，这样就不会有乱码问题了

　　下面我们来看ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是两个字节

　　新的问题又出现了，如果统一成Unicode编码，乱码问题从此消失了。但是写的文本基本上全部是英文时，用Unicode编码比ASCII编码多一倍存储空间，在存储和传输上十分不划算

　　所以出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1~6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4~6个字节

　　UTF-8编码有一个额外的好处，就是ASCII编码实际上可以看成是UTF-8的一部分

　　·现在我们可以总结一下现在计算机系统通用的字符编码工作方式：在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或需要传输时，可以转换为UTF-8编码

　　python用的就是UTF-8的

7.注释

　　注释必须以“#”符号开始，注释可以独占一行，也可以放在语句行的末尾

　　注释最重要的用途在于解释代码并不显而易见的特性