Python_Day2_基础2

python基础之数据类型与变量

• 一.变量

  变量作用：保存状态（程序的运行本质是一系列状态的变化，变量的目的就是用来保存状态，变量值的变化就构成了程序运行的不同结果。）

Age=10 ----> Int(10)-------->__int__()

  变量命名规则遵循标识符命名规则

链式赋值（y＝x＝a＝1）、多元赋值（x,y=1,2）、增量赋值（x+=1）

• 二.数据类型
• 2.1 什么是数据类型及数据类型分类

  程序的本质就是驱使计算机去处理各种状态的变化；

             python中的数据类型：

     python使用对象模型来存储数据，每一个数据类型都有一个内置的类，每新建一个数据，实际就是在初始化生成一个对象，即所有数据都是对象
对象三个特性

          身份：内存地址，可以用id()获取

          类型：决定了该对象可以保存什么类型值，可执行何种操作，需遵循什么规则，可用type()获取

          值：对象保存的真实数据

• 2.2 标准数据类型：
• 2.2.1 数字

  定义：a＝1

  特性：

  1.只能存放一个值

  2.一经定义，不可更改

  3.直接访问

  分类：整型，长整型，布尔，浮点，复数

• >>> 10 10 --------->默认十进制

• >>> oct(10) '012' --------->八进制表示整数时，数值前面要加上一个前缀“0”

• >>> hex(10) '0xa' --------->十六进制表示整数时，数字前面要加上前缀0X或0x

• 2.2.1.1 整型:

整型工厂函数int()

class int(object):

　　"""

　　int(x=0) -> int or long

　　int(x, base=10) -> int or long

def __abs__(self): """ 返回绝对值 """

def __cmp__(self, y): """ 比较两个数大小 """

def __coerce__(self, y): """ 强制生成一个元组 """

def __float__(self): """ 转换为浮点类型 """

def __hex__(self): """ 返回当前数的 十六进制 表示 """

def __oct__(self): """ 返回改值的 八进制 表示 """

def __int__(self): """ 转换为整数 """

def __ceil__(self, *args, **kwargs): # real signature unknown """ 整数返回自己 如果是小数 math.ceil(3.1)返回4

.....Etc

• 2.2.1.2 长整型long：

  注意，自从Python2起，如果发生溢出，Python会自动将整型数据转换为长整型，
  所以如今在长整型数据后面不加字母L也不会导致严重后果了。
  python3.*
  长整型，整型统一归为整型

• 2.2.1.3 布尔bool:

  True 和False
  1和0

• 2.2.1.4 浮点数float:

  Python的浮点数就是数学中的小数，在运算中，整数与浮点数运算的结果是浮点数。

• 2.2.1.5 复数complex:

  复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

• 2.2.1.6 数字相关内建函数

• 2.2.2 字符串

  定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘  ’‘’中间包含的内容称之为字符串
  特性：
  1.只能存放一个值
  2.不可变
  3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
  补充：
  　　1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'
  　　2.unicode字符串与r连用必需在r前面，如name＝ur'l\thf' 

• 2.2.2.1 字符串创建

  ‘hello world’

• 2.2.2.2 字符串常用操作

  移除空白
     分割
     长度
     索引
     切片

• 2.2.2.3 字符工厂函数str()

  class str(object):
      """
      str(object='') -> str
      str(bytes_or_buffer[, encoding[, errors]]) -> str

def capitalize(self): # real signature unknown; restored from __doc__ """ 首字母变大写 S.capitalize() -> str

def center(self, width, fillchar=None): # real signature unknown; restored from __doc__ """ 原来字符居中，不够用空格补全 S.center(width[, fillchar]) -> str

　　　　　　def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ """ 从一个范围内的统计某str出现次数 S.count(sub[, start[, end]]) -> int

　　　　　　def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__ """ 将字符串中包含的\t转换成tabsize个空格 S.expandtabs(tabsize=8) -> str

　　　　　　def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ """ S.find(sub[, start[, end]]) -> int

def format(self, *args, **kwargs): # known special case of str.format

""" 格式化输出 三种形式：

形式一. >>> print('{0}{1}{0}'.format('a','b'))

aba

　　　　　　形式二：（必须一一对应）

>>> print('{}{}{}'.format('a','b'))

Traceback (most recent call last): File "<input>", line 1, in <module> IndexError: tuple index out of range

>>>print('{}{}'.format('a','b'))

ab

　　　　　　 形式三：

　　　　　　 >>> print('{name} {age}'.format(age=12,name='lhf'))

　　　　　　 lhf 12

def isdigit(self): # real signature unknown; restored from __doc__ """ S.isdigit() -> bool

　　　　　    def join(self, iterable): # real signature unknown; restored from __doc__ """

　　　　　   #对序列进行操作（分别使用' '与':'作为分隔符）

　　　　　   >>> seq1 = ['hello','good','boy','doiido']

　　　　　　>>> print ' '.join(seq1)

　　　　　　hello good boy doiido

　　　　　　>>> print ':'.join(seq1)

　　　　　　hello:good:boy:doiido

　　　　　　 #合并目录

　　　　　　>>> import os

　　　　　　>>> os.path.join('/hello/','good/boy/','doiido')

　　　　　　 '/hello/good/boy/doiido'

          def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__ 
　　　　　　""" 以sep为分割，将S切分成列表，与partition的区别在于切分结果不包含sep， 如果一个字符串中包含多个sep那么maxsplit为最多切分成几部分 
　　　　　　>>> a='a,b c\nd\te' 
　　　　　　>>> a.split() 
　　　　　　['a,b', 'c', 'd', 'e']    

　　　　　　def splitlines(self, keepends=None): # real signature unknown; restored from __doc__ 
　　　　　　""" Python splitlines() 按照行('\r', '\r\n', \n')分隔， 返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如 果为 True，则保留换行符。
　　　　　　>>> x 
　　　　　　'adsfasdf\nsadf\nasdf\nadf' 
　　　　　　>>> x.splitlines() 
　　　　　　['adsfasdf', 'sadf', 'asdf', 'adf'] 
　　　　　　>>> x.splitlines(True) 
　　　　　　['adsfasdf\n', 'sadf\n', 'asdf\n', 'adf']
　　　　　　...Etc

• 2.2.3 列表

　　　　定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
　　　　特性：
　　　　1.可存放多个值
　　　　2.可修改指定索引位置对应的值，可变
　　　　3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序　

• 2.2.3.1 列表创建

　　　　list_test=[’lhf‘,12,'ok']
　　　　或
　　　　list_test=list('abc')
　　　　或
　　　　list_test=list([’lhf‘,12,'ok'])

• 2.2.3.2 列表常用操作

　　　　索引
　　　　切片
　　　　追加
　　　　删除
　　　　长度
　　　　切片
　　　　循环
　　　　包含　　

• 2.2.3.3 列表工厂函数list()

　　　　class list(object): """ list() -> new empty list

　　　　def append(self, p_object)

　　　　def clear(self)

　　　　def copy(self):两份内存

　　　　def count(self, value)

　　　　def insert(self, index, p_object)

　　　　def pop(self, index=None)：删除并返回    pop[]:默认删除最后一个

　　　　def remove(self, value)

　　　　def reverse(self)

　　　　def sort(self, key=None, reverse=False)

　　　def index(self, value, start=None, stop=None)
　　　def extend(self, iterable)：两个列表的合并拼接　
　　　...Etc

• 2.2.4 元组
• 2.2.4.1 元组创建
• 2.2.4.2 元组常用操作
• 2.2.4.3 元组工厂函数tuple()
• 2.2.5 字典
• 2.2.5.1 字典创建
• 2.2.5.2 字典常用操作
• 2.2.5.3 字典工厂函数dict()
• 2.2.6 集合
• 2.2.6.1 集合创建
• 2.2.6.2 集合常用操作：关系运算
• 2.2.6.3 集合工厂函数set()
• 2.2.7 bytes类型
• 2.2.8 数据类型转换内置函数汇总
• 三.运算符

　　　1、算数运算 2、比较运算 3、赋值运算 4、位运算

　　　5、逻辑运算(与或非) 6、成员运算 （in not in）7.身份运算（is is not）8.运算符优先级：自上而下，优先级从高到低

and注解：

1. 在Python 中，and 和 or 执行布尔逻辑演算，如你所期待的一样，但是它们并不返回布尔值；而是，返回它们实际进行比较的值之一。
2. 在布尔上下文中从左到右演算表达式的值，如果布尔上下文中的所有值都为真，那么 and 返回最后一个值。
3. 如果布尔上下文中的某个值为假，则 and 返回第一个假值

　　or注解：

1. 使用 or 时，在布尔上下文中从左到右演算值，就像 and 一样。如果有一个值为真，or 立刻返回该值
2. 如果所有的值都为假，or 返回最后一个假值
3. 注意 or 在布尔上下文中会一直进行表达式演算直到找到第一个真值，然后就会忽略剩余的比较值

　　and-or结合使用：

1. 结合了前面的两种语法，推理即可。
2. 为加强程序可读性，最好与括号连用，例如：

   （1 and 'x') or 'y'

• 四.标准数据类型特性总结