初识:

    print('hello world')
    print("hello world")
    print('hello','world')
错误方式:
    ERROR:print 'hello'
    ERROR:print "hello"

Python基本数据类型:

  • 类型: Number包括整数+小数
  • 整数: int
  • 浮点数:float(不分精度)
  • 布尔型:bool
  • 复数: complex // 36j

简单运算

判断数据类型 type(param)
类型合并原则:
    向精度更高的方向合并,结果为高精度
示例:
    type(1+1.1111111)  为float类型
    type(1*1.1111111) 为float类型
    type(2/2) float
    type(2//2) int 结果为整形

    2/2 = 1.0
    2//2 = 1

    1//2 = 0 
    1/2 = 0.5
    注意:
        符号 /  自动转换类型
        符号 // 整除,向下取整
注意:
    Python2中有long类型,3版本后去掉
    错误的方式:数字+字符串,这里不同于Java,不能直接相加

进制

形式:
    int类型的不同进制
示例:
    type(0xFFFFF) 均为int类型
    但是,其默认转为进制计算,如下:
        >>> 0xFFFFF
        1048575
注意:
    逗号运算符,自动拼为元组
    >>> 0x0,'1'
    (0, '1')
    可以混合,可以识别元组

进制转换

表示:
    二进制 [b]  0b0101 = 十进制 5 
    八进制 [o]  0o10   = 十进制 8 
    16进制 [x]  0xF    = 十进制 15

转换-利用方法   
    任意进制->二进制:bin() bin(10) = '0b1010'
    任意进制->十进制:int()
    任意进制->16进制:hex()
    任意进制->八进制:oct()

布尔类型

形式:
    True  ERROR:true.TRUE

转化:
    int(True) = 1     bool(1) = True

注意:
    无论正负小数,只要非零,皆为True
示例:
    >>> bool('')
    False
    >>> bool('a')
    True
    >>> bool([]) //列表
    False
    >>> bool([1,2,3])
    True

注意:
    False = 0 . [] . {} . '' 。 None 均为假

字符串:str

形式:
    ''单引号
    ""双引号   
    '''-'''或者"""-"""三引号 含换行的字符串输入
示例:
    正确的:" It's me."
    正确的:' It\'s me.' 可以转义
    正确的:' He is ". ' 双引号在内

三引号:
    可以在代码中换行输入
    代码:
        >>> '''2'
        22'
        222222'
        2'''''
        "2'\n22'\n222222'\n2"

显示换行:
    需要使用print
    代码:
        >>> "2'\n22'\n222222'\n2"
        "2'\n22'\n222222'\n2"
        >>> print("2'\n22'\n222222'\n2")
        2'
        22'
        222222'
        2

IDLE特点:
    使用\也可以换行
    代码:
        >>> 'hello\
        world'
        'helloworld'
注意:
    转义字符,与语言本身有冲突
    \n  \'  \t 
    单个斜杠:\\    '\\t'= '\t'
应用:    
    文件路径不允许单个\出现 C:\\windows
    print('C:\\windows')
    print(r'C:\windows') 字符加r之后,可以忽略转义分歧

字符串操作方法

形式:
    运算符:只有 + * 没有 - /
    取单值:[index]
    取多值:[m:n]
    串合并:'a'+'b' = 'ab'
    串分割:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
示例:
str[index]:直接转为字符数组,
'who'[ 0] = 'w' 参数为正·是数组下标
'who'[-1] = 'o' 参数为负·是从右起第几个
str[ m : n ]:截取一段,只有m或n时都不会返回单值
str[ 起始 : 长度 ] :
不写起始 str[__: 长度 ],默认为str[0 : 长度 ]
不写长度 str[起始 : __ ],默认为str[起始 : 截取到最右 ]
'who'[0:0] = ''
注意第一个参数取得不是下标,'who'[0:] = 'who'
注意第二个参数取得不是下标,'who'[0:0] 不是 'who'[ 0]
'who'[0:3] = 'who'
'who'[0:-2] = 'w'
从右起拿掉2位之后剩余‘w’
'who'[0:10]
多余位数自动丢弃,不会报错
'who'[3:-2] = ''
从左开始,数三位是o,从o开始,往左数两个,为''
'who'[-3:-2] = 'w'
从右开始,数三位是'',从''开始,即等效于'who'[0:-2] 从右往左数两个,为'w'
'who'[-2:] = 'ho'
从w开始,截取到最右:ho

元组tuple

多种方式:
    <class 'list'> 列表[]    元素可以混合
    <class 'tuple'>元组()    元素可以混合
全空类型:
    () , []
定义方式:
    type([1,2,3,'a',False])
    [1,2,3,[True,'b'],'a'] 嵌套列表
    [,,,] 不能为空
访问方式:
    [1,2,3,4][0] = 1            取单值时,取出元素本身
    [1,2,3,4][0:3] = [1,2,3]    取多值时,取出仍为列表
操作方式:同串类似
    + 操作 :[1,2]+[3,4] = [1, 2, 3, 4]
    * 操作 :[1,2]*2 = [1, 2, 1, 2]     [1,2]*2 = []
    上述操作结果均为一层列表包裹

列表和元组的区别:

对待单元素的处理不同
    type(('a')) -- <class 'str'> 作为运算符括号处理,规定
    type(['a']) -- <class 'list'> 
    定义单元素元组 type(('a',)) = ('a')
赋值的区别
    元组(1,2)[0] = 1 是错误的,不支持赋值
    列表[1,2][0] = 1 正确,结果为[2,2]

总结:

int,float,bool,complex   简单类型
str,list,tuple            称之为“序列”
“序列”的共有操作:
    取单值          序列[m]         有序号,有序
    取多值(切片)    序列[m:n]      高级用法 序列[m:n:p] 
共有的高级方法:
    判断序列是否在本序列:in     
        'a' in 'abc'或者2 in [1,2,3]或者2 in (1,2,3)
        2 in [1,2,3] = True 反之:2 not in [1,2,3] = False
    得到序列长度:
        len(()) = 0     len('1234') = 4 
    得到序列最大最小元素:
        max(),min() 去包装的返回值
        max('abcd') = 'd'                 按ASCII(ord(''))码值,空格等照样
        max([(1,2),(1,2,3)]) = (1,2,3)    元组长度最大

无序:集合

type({1,2,3,4}) = <class 'set'>

特性:
    无序        序列操作方式不适用 集合,集合元素没有一个固定下标
    不重复      {1,1,2,2,3,4} = {1,2,3,4}
    公共        len(),  in, not in
    集合运算    - & |
运算:
    差集    {1,2,3} - {1} = {2,3}
    交集    {1,2} & {2,3} = {2}
    并集    {1,2} | {2,3} = {1,2,3}
    上述运算符中均不能出现{}空集合,另外结果会自动去掉重复
注意:
    直接使用{}定义的不是空集合,其类型为字典:<class 'dict'>
    定义空集合:set(),即为type(set()) = <class 'set'>
    列表内不能含有列表或者字典元素
        {1,{1,2,3}}是错的,可以含有元组,字符串和整形的混合

无序:字典

不是序列,类似于集合,但不同
定义方式:
    {'name':'tom','sex':'wm'}  type类型是   <class 'dict'>

取值:通过Key访问Value
    {'name':'tom','sex':'wm'}['name'] = 'tom'
    {(1,2):'a','name':'b','sex':'wm'}[(1,2)] = 'a'
    {'name':'a','name':'b','sex':'wm'}['name'] = 'b'
    字典不能有重复键值对,如果重复,运算之前会自动去重
    字典的Key必须为不可变类型  int,str,tuple  list和set不行   
    字典的Value类型不限        {2:{2:'a'}}[2][2] = 'a'
    定义空字典:直接{}         type({}) = <class 'dict'>

基本类型总结

int,float,bool,complex       
1            1.2             False      20j
str,list,tuple                
'a'          [1,2]  列表     (1,2) 元组    
set,dict                       
{1,2} 集合   {1:"2"}字典

不可变类型
    整形 布尔型 字符串 元组  int,bool,str,tuple
可变类型
    列表 集合 字典 [list],{set},{dict}

集合 无序,无索引,不能切片
字典 类似集合,不是序列