(一) pyhon 基础语法(数值字符串元组列表字典)

时间 2019-11-19

标签 pyhon 基础语法数值字符串列表字典繁體版

原文原文链接

一、python的数据类型：数值字符串列表元组字典；python

数值类型包括；整型(int) 长整型(long) 浮点型(float) 复数型字符串；linux

能够经过type() 来查看是什么类型的；bash

注释：len()只支持字符串类型,不支持浮点数和整数；数据结构

1:整型：表示的数字,好比 0 100 -100 等；整数又分为正整数和负整数；app

整数范围： 2**32 次方；函数

In [8]: a = 123
In [9]: type(a)
Out[9]: int

In [10]: 2**32
Out[10]: 4294967296
In [11]: 2**31
Out[11]: 2147483648

注释：整数的范围： -2147483648 到 2147483648 加起来恰好；4294967296ui

2：长整型 long 后面会加L；或者是定义的值很大时, 或者在自定的数值后面加L也能够；code

In [12]: a = 129999999999999999999999999999999999999
In [14]: a
Out[14]: 129999999999999999999999999999999999999L

In [15]: a = 100l
In [16]: a
Out[16]: 100L
In [17]: type(a)
Out[17]: long

3:浮点型；后面带小数点 0.0 12.0 -18.8 3e+7对象

In [18]: a = -0.18

In [19]: type(a)
Out[19]: float

In [20]: a = 3e+7

In [21]: type(a)
Out[21]: float

4:复数型；后面加 j -3.14j 排序

In [22]: a = -3.14j

In [23]: type(a)
Out[23]: complex

5:字符串 str

给变量赋值字符串时,能够有三种方法: 单引号双引号三引号 /n 表示换行符；

注释：三引号能够用做定义字符串,也能够用做注释；再使用定义字符串时,必须是三个单引号,或者三个双引号,不能单双混用；

In [24]: a = 'abc'

In [25]: type(a)
Out[25]: str

In [26]: a = "abc"

In [27]: type(a)
Out[27]: str

/n 表示换行符；

In [33]: a = """hello\nworld"""

In [34]: a
Out[34]: 'hello\nworld'

In [35]: print a
hello
world

In [30]: a = '''hello
    ...: world'''

In [31]: a
Out[31]: 'hello\nworld'

In [32]: print(a)
hello
world

注释：字符串时一个序列,那么针对序列操做的时候能够经过索引和切片来操做,

索引：第一个字符表示0,依次日后,最后一个字符能够用 -1 表示；

In [37]: a
Out[37]: 'abcde'
In [38]: a[0]
Out[38]: 'a'
In [39]: a[1]
Out[39]: 'b'
In [40]: a[4]
Out[40]: 'e'
In [41]: a[-1]
Out[41]: 'e'

切片：好比咱们须要去 ab 两个字符,固然能够用链接符 + 号 a[0]+a[1]

In [42]: a[0]+a[1]
Out[42]: 'ab'

In [43]: a[0:2]
Out[43]: 'ab'
In [44]: a
Out[44]: 'abcde'

也可使用切片的方式： a[0:2] 0表示a的下标依次 2 表示 c 的下标,不过不显示；不过 0 也能够省略的； a[:2]

均可以省略表示所有内容； a[:]

a[::2] 表示步长值为 2 ，表示隔两步一取; 显示为 ace；

注释：a[-1] 表示e,最后一个字母,

也能够从后往前取,好比 a = abcde 若是取 bc 的话, 那就是 a[-4:-2]

In [58]: a = 'abcde'
In [59]: a
Out[59]: 'abcde'

In [60]: a[-4:-2]
Out[60]: 'bc'

默认是从左到右的；也能够从右到左的；好比 a = abcde 若是取 db 的话, 那就是 a[-2:-4:-1] -1 表示方向

In [61]: a = 'abcde'

In [62]: a[-2:-4:-1]
Out[62]: 'dc'

四、元组：序列包括字符串列表元组；

序列的主要特色就是可使用索引操做切片操做；索引是取某一个字符, 切片取一组字符；

序列的基本操做：

len() 求序列的长度；

+ 用来链接两个序列；

* 重复序列元素；

in 判断元素是否存在序列中；

max() 返回最大值；

min() 返回最小值；

cmp(x,y) 判断两个序列是否相等；

In [63]: a = 'abcde'

In [64]: len(a)                 #求字符串长度;
Out[64]: 5

In [65]: a + 'f'                #字符串相加;
Out[65]: 'abcdef'
In [69]: b = 5

In [70]: b + 6                  #数值相加;
Out[70]: 11

如上图：len 能够用来求数据的长度；

+ 加号,能够用来序列相加；能够是同一类型相加(字符串相加数值相加)，也能够不一样类型( 字符串和数字相加)----不过须要转换一下；

In [84]: name = 'wo jin nian'

In [85]: h = 'sui'

In [86]: name + str(age) + h
Out[86]: 'wo jin nian24sui'

# 号表示重复,后跟数字,表示重启的前面的多少次；

'#' * 50
Out[89]: '##################################################'

in 判断元素是否在序列里；

判断 a 是否在 a 这个序列中, 存在则返回true，不存在则返回flase；已知 a = 'abcde'

In [91]: a= 'abcde'

In [92]: 'a' in a
Out[92]: True

In [93]: 's' in a
Out[93]: False

还有not in 表示取反, 'f' not in a 表示 f 若是不在 a 这个序列里,则返回true, 若是在则返回flase；

In [94]: 'f' not in a
Out[94]: True

In [95]: 'f' not in a+'f'
Out[95]: False

max() 求最大值 min() 求最小值

In [99]: b = '12345'
In [102]: type(b)
Out[102]: str

In [100]: max(b)
Out[100]: '5'

In [101]: min(b)
Out[101]: '1'

注释：max()和min() 只支持序列(字符串类型)
cmp(x, y) 比较两个序列是否相等；若是 x > y 则返回正整数, x < y 返回负整数, x = y 返回0 ；

In [113]: a= 'abcde'

In [114]: cmp(a, 'abcde')       # a 则表示上面的变量,它俩相等;因此返回是0 ;
Out[114]: 0

In [115]: cmp(a, 'abcdef')      # a 小于右边的字符串,因此返回是负整数 -1 ;
Out[115]: -1

In [116]: cmp(a+'g', 'abcdef')    # a 大于右边的字符串,因此返回是正整数 1 ;
Out[116]: 1

注释：两个序列是否相等；若是 x > y 则返回正整数, x < y 返回负整数, x = y 返回0 ；

五、元组() 能够存储一系列的值,和字符串同样是不可变的(里面的内容不能够改变)

如何定义元组呢？多个元素用 , 逗号分开；

t = ('a',1,(1,)) 表示里面存放的字符串 a 数字 1 , 又存放了元组 1 ;

In [119]: t = ('a',1,(1,))

In [120]: t
Out[120]: ('a', 1, (1,))

In [121]: type(t)
Out[121]: tuple

元组一般用于接受函数的返回值；以下；

定义t = (a, 'b', 'c') 这三个元素,其中a是表示以前定义的变量abcde,未加引号, b 和 c 表示字符串；

而后经过三个变量去接收这个值； first 第一个值 second 第二个值 third 第三个值；

In [122]: t = (a, 'b', 'c')
In [123]: t
Out[123]: ('abcde', 'b', 'c')

In [127]: first, second, third = t
In [128]: first
Out[128]: 'abcde'
In [129]: second
Out[129]: 'b'
In [130]: third
Out[130]: 'c'

t.count

python里面的变量字符串序列都称为对象；

元组和字符串同样属于序列类型,也能够经过序列和切片操做；

元组拆分；

t = ('a', 'b', 'c') A, B, C = t

六、列表：是一种有序项目的项目的数据结构,列表是可变数据类型的数据；

建立列表；

list = [] 建立空列表；

list2 = list() 经过list()函数来建立空列表；

list3 = ['a',1,2] 建立列表；

In [146]: list1 = []             #建立空列表;
In [148]: type(list1)
Out[148]: list

In [149]: list2 = list()        #经过list函数来建立列表：
In [150]: type(list2)
Out[150]: list
In [151]: list2
Out[151]: []

In [152]: list3 = ['a',1,(1,),['hello', 'python']]     #建立list列表;
In [153]: list3
Out[153]: ['a', 1, (1,), ['hello', 'python']]

In [154]: len(list3)
Out[154]: 4

列表的特性：列表的值时可变的；经过索引的方式把list3的值第 0 位变成 a；

In [167]: list3
Out[167]: ['b', 1, (1,), ['hello', 'python']]
In [168]: list3[0]
Out[168]: 'b'
In [169]: list3[0] = a
In [170]: list3
Out[170]: ['abcde', 1, (1,), ['hello', 'python']]

三、往空列表里追加： list2为以前建立的空列表；经过 list2 = list() 函数建立；

给列表添加元素： list2.append( )

In [181]: list2.append('linux')

In [182]: list2
Out[182]: ['linux']

In [183]: list3 + list2
Out[183]: ['abcde', 1, (1,), ['hello', 'python'], 'linux']

注释：而后能够把list3和list2 相加;

也能够重复以前的列表，用 * 号； (list3) * 2 (list3+list2) * 2 先加再乘；

In [185]: (list3) * 2
Out[185]: ['abcde', 1, (1,), ['hello', 'python'], 'abcde', 1, (1,), ['hello', 'python']]

Out[186]: ['linux', 'linux']
In [187]: (list3 + list2) * 2
Out[187]: 
['abcde',
 1,
 (1,),
 ['hello', 'python'],
 'linux',
 'abcde',
 1,
 (1,),
 ['hello', 'python'],
 'linux']

六、删除列表中的元素：两种方式以下； del list2 表示删除真个list2 列表；

###可使用help(list.remove)查看帮助等；

del list3[4] 须要知道它的下标才可以删除； 0 1 2 3 -l (最后表示 -1 )

list.remove(1) #默认删除是first第一个value；

In [204]: list3
Out[204]: ['abcde', 1, (1,), ['hello', 'python']]

In [205]: del list3[-1]                #第一种方式,删除最后一个元素;
In [206]: list3
Out[206]: ['abcde', 1, (1,)]

In [209]: list3.remove(1)              #删除第一个元素;

In [210]: list3
Out[210]: ['abcde', (1,)]

七、查找； in

'a' in list3 表示 a 是否在这个列表,若是在,返回true,若是不在返回flase；

'a' not in list3 表示a 是否在这个列表,若是在,返回flase,不过则返回true；

In [210]: list3
Out[210]: ['abcde', (1,)]

In [211]: 'a' in list3
Out[211]: False
In [215]: 'abcde' in list3
Out[215]: True

In [216]: 'a' not in list3
Out[216]: True

In [217]: 'abcde' not in list3
Out[217]: False

修改字符；列表 list3 的 0 位修改成 b ;

list3[0] = 'b'

In [218]: list3
Out[218]: ['abcde', (1,)]

In [219]: list3[0] = 'b'

In [220]: list3
Out[220]: ['b', (1,)]

list.insert 插入空的列表；

In [220]: list3
Out[220]: ['b', (1,)]

In [221]: list3.insert(1, list1)

In [222]: list3
Out[222]: ['b', [], (1,)]
插入了一个空列表;

给空列表里写入值； list3[1].append('abc')

In [225]: list3[1].append('abc')

In [226]: list3
Out[226]: ['b', ['abc'], (1,)]

列表排序： list.sort

list3.sort()

In [227]: list3
Out[227]: ['b', ['abc'], (1,)]

In [228]: list3.sort()

In [229]: list3
Out[229]: [['abc'], 'b', (1,)]

反转(最后一位变成了第一位)； list.reverse

In [229]: list3
Out[229]: [['abc'], 'b', (1,)]

In [230]: list3.reverse()

In [231]: list3
Out[231]: [(1,), 'b', ['abc']]

list.pop 根据下标来删除,当时会返回一下当前值；

如咱们删除list3 中下标为 1 的,使用 list.pop 不只会删除,还会返回删除的这个值；

In [231]: list3
Out[231]: [(1,), 'b', ['abc']]

In [232]: list3.pop()
Out[232]: ['abc']

In [233]: list3
Out[233]: [(1,), 'b']

注释：默认什么也不加,会删除最后一个；如上图例；

list.ectend，可迭代的,会把新增的追加列表里； list3.extend(range(5))

In [248]: range(5)
Out[248]: [0, 1, 2, 3, 4]

In [249]: list3.extend(range(5))

In [250]: list3
Out[250]: [(1,), 'b', 0, 1, 2, 3, 4]

list.exxend 会把元素迭代追加进去；

list3.exxtend('abcde')

In [255]: list3.extend('abcde')

In [256]: list3
Out[256]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

也能够追加元组： list3.extend(('t1', 't2'))

注释：字符串元组列表都是可迭代的对象；可迭代的能够经过for循环去访问；

list.count(value) 若是判断这个value值在当前的列表里,则返回是一个整数,不然不在则返回0；

In [282]: list3
Out[282]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

In [284]: list3.count('b')
Out[284]: 2

In [285]: list3.count('e')
Out[285]: 1

In [286]: list3.count('x')
Out[286]: 0

list.index(value) 表示返回索引号；

In [287]: list3
Out[287]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

In [288]: list3.index('b')
Out[288]: 1

In [289]: list3.index('d')
Out[289]: 10

In [290]: list3.index('e')
Out[290]: 11

八、字典：是python里面的数据结构,字典的对象value是可变的,可是字典的键值key是不可变的,一个字典可使用不一样类型的键值(元组)；不能使用列表list,由于列表是可变的, 由于字典是hash 表显示是无序的；

可用来存储一我的年龄身高性别等；

固然字符串也能够存储的,可是若是有的姓名不是3个,那就取得不全的；

info = 'tom 180 man'

info[0:3]
'tom'
固然也能够存储元组里,可是元组一旦定义完以后,里面的元素就不能更改,那么若是增长联系人等信息就没法添加了；

固然也能够存储到列表里, 可是未来取数据也比较麻烦,经过下标来取,不知道索引就没法取了；

以下：先建立一个list1 list2 list3 并用zip函数把他们链接到一块儿；而后把这些信息放到字典里,而后取就很方便了；

In [298]: list1 = ['name', 'age']
In [300]: list2 = ['tom','20']
In [301]: list3 = ['mike','25']

In [302]: list2
Out[302]: ['tom', '20']

In [303]: zip(list1, list2)
Out[303]: [('name', 'tom'), ('age', '20')]
In [304]: list1
Out[304]: ['name', 'age']
In [305]: list2
Out[305]: ['tom', '20']

In [306]: zip(list1, list3)
Out[306]: [('name', 'mike'), ('age', '25')]

注释：zip函数会把两个列表合并,组成一个大的列表；

注释：列表 [ ] 元组 ( ) 字典 { } 字符串 ' '

字典的方法：

keys()

values()

items()

建立字典； dic { }

dic = {'a':1, 1:123} a 表示key 键值 1 表是 value 中间用冒号：隔开；

In [307]: dic = {}

In [308]: type(dic)
Out[308]: dict

In [309]: dic = {'a':1, 1:123}           #建立两对数据; key - value 对应;

In [310]: dic
Out[310]: {1: 123, 'a': 1}

二、那么用元组()做为key值来建立字典；以下；由于元组()是不可变的,能够用来当作key 键值； dc = {('a','b'):'hello'}

In [313]: dc = {('a','b'):'hello'}

In [314]: type(dc)
Out[314]: dict

In [315]: dc
Out[315]: {('a', 'b'): 'hello'}

三、那么用list[]来做为key 值建立字典,不能够的,由于list是可变的；

In [317]: dc1 = {[1]:1}
------------------------------------------------------------
TypeError                  Traceback (most recent call last)
<ipython-input-317-c906c08b610a> in <module>()
----> 1 dc1 = {[1]:1}

TypeError: unhashable type: 'list'

注释：如上图例,全部list[ ] 不能当作字典的键值 key 来使用；

len(dic) 也能够看字典的长度；

四、字典的参数以下；

dic.key() 返回全部key值组成一个列表list并显示；

In [319]: dic.keys()
Out[319]: ['a', 1, ('a', 'b')]

dic.values() 返回全部value值组成一个列表list并显示；

In [320]: dic.values()
Out[320]: [1, 123, 'hello']

(一) pyhon 基础语法(数值 字符串 元组 列表 字典)

(一) pyhon 基础语法(数值字符串元组列表字典)