【1】语法基础----(1)[基础数据类型]

1.整数

2.浮点数

3.字符串

4.列表

5.元组

6.索引切片

7.不可变数据类型探究

8.范围赋值，单独赋值详解

Python 支持四种不同的数值类型：

整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
浮点型(floating point real values) - 浮点型由整数部分与小数部分组成。小数有精度
复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

【1】整型用 [int] 表示，python2中用L表示长整型，python3没有长短之分。

#Python2:
>>> a = 3248123846172346712364713284
>>> a
3248123846172346712364713284L
#Python3:
>>> a = 3248123846172346712364713284
>>> a
3248123846172346712364713284
#查看数据类型type()
>>> type(a)
<class 'int'>

【2】浮点数 [float] 即小数，python采用四舍6入5看齐规则取代4舍五入规则,这样可将误差降到最低。

round()函数返回四舍5入值

>>> a = 5.21534
>>> round(a,2)
5.22
>>> round(a,3)
5.215
>>> round(a)
5.0
>>> type(2.323)
<type 'float'>

(1)要求保留位数的后一位如果是4或者4以下的数字，则舍去， 例如 5.214保留两位小数为5.21。
(2)如果保留位数的后一位如果是6或者6以上的数字，则进上去， 例如5.216保留两位小数为5.22。
(3)如果保留位数的后一位如果是5，且该位数后没有数字。要根据保留位数的那一位决定是舍去还是进入：如果是奇数则进入，如果是偶数则舍去。如:5.215保留两位小数为5.22，5.225保留两位小数为5.22。
(4) 如果保留位数的后一位如果是5，且该位数后有数字。则进上去，例如5.2152保留两位小数为5.22，5.2252保留两位小数为5.23，5.22500001保留两位小数为5.23。

* 复数【complex】复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

>>> type(1+2j)
<type 'complex'>

【*】布尔值：真True假Falses .[非0非空是真，0或空为假。]

>>> type(True)
<type 'bool'>
>>> type(False)
<type 'bool'>

[3]字符串[str]:str是一个不可变的数据类型如：a='abc',a[1]='e'会报错。但是可以重新给a赋值，如a='efg'

(1)创建字符串（给变量赋值用,可用 ’str’, ’’str’’, ‘’’str’’’, ”””str”””）

e = ’abc’

e = ’’abc’’

e = ‘’’abc‘’’

e = “””abc”””

(2)访问字符串的方法：【索引 + 切片 + for循环】

2.1:字符串索引访问：如：a='hello world',a[0]根据括号里面填写的值获取对应位置上的数据，从左向右从0开始。从右向左从-1开始。

>>> a = 'wangyunlong1992'
>>> a[0]
'w'
>>> a[-1]
'2'

2.2:字符串切片访问：取一个范围的值，特点：左闭右开。在有步长时，是包含本身的。a='helloworld' a[0:4] 值：hell最后的o是取不到的。a[x:y:z] x表示开始的索引，y表示结束的索引，x表示步长

>>> a = 'wangyunlong1992'
>>> a[0:-1]
'wangyunlong199'
>>> a[0:]
'wangyunlong1992'
>>> a[:]
'wangyunlong1992'
>>> a[-4:-1]
'199'
>>> a[1:3]
'an'
>>> a[::-1]
'2991gnolnuygnaw'
>>> a[::-2] #步长为-2
'29gonynw'
>>> a
'wangyunlong1992'
>>> a[-4:-1]
'199'
>>> a[-1:-4:-1]步长为-1，索引不变，-1=2991gnolnuygnaw,然后-1，-4=299
'299'
>>> a[-1:-4:-1][:1];先进行 a[-1:-4:-1]的访问值为299，在对299进行[:-1]的切片，此时索引重新维护，运算： a[-1:-4:-1][:-1] ----299[:-1]----->2
'2'

2.3:字符串迭代访问for循环

>>> a = 'wang'
>>> index = 0
>>> for var in a:
...     print(a[index])
...     index +=1
w
a
n
G>>> a= '123'
>>> for var in list(a):print(var)
1
2
3

（3）字符串加法：

>>> a = 'wang'
>>> b = 'yun'
>>> c = 'long'
>>> print('a+b+c结果为:',a+b+c)
a+b+c结果为: wangyunlong

（4）字符串乘法：

>>> a = '8'
>>> a * 2
'88'
>>> a = 'wyl_'
>>> a * 3
'wyl_wyl_wyl_'

（5）重新更新赋值：

>>> a = "wangbang"
>>> print("更新字符串:",a[:4] + 'yunlong' )
更新字符串: wangyunlong

（6）字符串清空：

乘法清空
>>> a =a * 0
>>> a
''
切片清空
>>> a = '123'
>>> a=a[3:9]
>>> a
''
注：字符串乘法：只能和整数相乘，字符串加法只能拼接一个新的字符串。

(7)字符串格式化：常用格式符：%s 表示字符串，%d格式化整数，%f格式化浮点数,可指定小数点后的精度。

>>> print("我叫:%s ,今年:%d 岁.身高：%0.2f" %('wangdalong',20,170))
我叫:wangdalong ,今年:20 岁.身高：170.00

(8)检查成员：in , not in

>>> a = 'wangyunlong'
>>> if 'wang' in a:
...     print('wang在a中')
wang在a中
>>> if 'ngol' not in a:
...     print('ngol不在a中')
ngol不在a中

(9)字符串取空格：

str.strip()
>>> a = '   abcd'
>>> a
'   abcd'
>>> a.strip()
'abcd'
>>>
>>> expr = '   2 +  3 '
>>> expr[5] 可以通过if匹配，如果条件成立就break
'+'
>>> expr[:5].strip()  通过切片获取2
'2'
>>> expr[5+1:].strip() 通过切片获取3
'3'

【3】列表[list]:序列都可以进行的操作包括索引，切片，加，乘，检查成员,列表可以包含任意字符类型如：[浮点数，整数，布尔值，整数列表，字符串列表,字符串]。

(1)创建访问列表（索引切片）:

>>> a=[1,2,3,4,5,6,7,8,9,0]
 >>> a[-1:-10:-1]
[0, 9, 8, 7, 6, 5, 4, 3, 2]
>>> a[-1:0:-1]
[0, 9, 8, 7, 6, 5, 4, 3, 2]
>>> a = [None]*10 #创建十个0的列表，None表示空。
>>> a
[None, None, None, None, None, None, None, None, None, None]
#访问列表当没有这个元素时会报错如：
>>> a = [1,2,3]
>>> a[5]
IndexError: list index out of range
#采用：切片访问不会报错如：
>>> a [5:]
[]
#For循环迭代访问：
>>> a=['a','b','c']
>>> index = 0
>>> for var in a:
...     print(a[index])
...     index += 1
a
b
C
>>> a = ['a','b','c']
>>> for var in a:print(var)
a
b
c

(2)列表：拼接（加法） + （重复）乘法

>>> a = [1,2,3,'wang','yun',[1,2,3,4]]
>>> b = ['long','10','89']
>>> a + b
[1, 2, 3, 'wang', 'yun', [1, 2, 3, 4], 'long', '10', '89']
>>> a = [1,2,3]
>>> a * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
注意：列表通过切片单独加一个列表中的元素会报错（运算），必须保持范围对范围，或单独元素相加

>>> a = [1,2,3,4,5]
>>> a[0:2]
[1, 2]
>>> a[3]
4
>>> a[0:2] + a[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "int") to list
>>> a[0:2] + a[3:]
[1, 2, 4, 5]

(3)列表的更新-通过索引或切片，切记如果切片步长大于1时，一个萝卜一个坑

>>> a = [1,2,3,4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> a[0]
1
>>> a[0] = 'a'
>>> a
['a', 2, 3, 4, 5, 6]
>>> a[:2]
['a', 2]
>>> a[:2] = 'wangyunlong'
>>> a
['w', 'a', 'n', 'g', 'y', 'u', 'n', 'l', 'o', 'n', 'g', 3, 4, 5, 6]
>>> a[:2]
['w', 'a']
>>> a[:2] = ['wang','yun']
>>> a
['wang', 'yun', 'n', 'g', 'y', 'u', 'n', 'l', 'o', 'n', 'g', 3, 4, 5, 6]
>>> a[:2]
['wang', 'yun']
>>> a[:2] = 'admin','root'
>>> a
['admin', 'root', 'n', 'g', 'y', 'u', 'n', 'l', 'o', 'n', 'g', 3, 4, 5, 6]
>>> a[::2] = 'a'
ValueError: attempt to assign sequence of size 1 to extended slice of size 8
切记：通过切片赋值时，当步长大于1时，一个萝卜一个坑。

(4)删除清空列表中的元素：del list[x]

>>> a
['a', 'root', 'g', 'c', 'u', 'd', 'l', 'e', 'n', 'f', 3, 'g', 5, 'h']
>>> del a[0]
>>> a
['root', 'g', 'c', 'u', 'd', 'l', 'e', 'n', 'f', 3, 'g', 5, 'h']
#清空列表：
>>> a.clear()
>>> a
[]
#删除列表：
del a
a
NameError: name 'a' is not defined

(5)判断元素a是否存在

>>> a = [1,2,3,4,5]
>>> if 1 in a:
...     print('1在列表中')
...     1在列表中

(6)统计列表元素的个数：通过函数Len(list)

['a', 'b', 'c']
>>> len(a)
3

【4】元组Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

（1）创建及访问元组与列表类似

>>> a = (1,2,3,4,5) #创建
>>> a[0]索引访问
1
>>> a[0:6] 切片访问
(1, 2, 3, 4, 5)
>>> a[:-1]
(1, 2, 3, 4)
>>> a = ()
>>> a
()
>>> a = (1,2,3)
>>> for var in a:print(var) 迭代访问
1
2
3
>>> a = ('a',) 切记当创建一个元素的元组时，用逗号隔开，不然创建的是一个元素，不是元组

>>> a

('a',)
>>> a
(1, 2, 3, 4, 5)
>>> del a #删除元组
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> a = (1,2,3,4)
>>> a[0]
1
>>> a[0] = 1 #不可变数据类型
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元组本身不可变数据类型，但是可以通过切片方式进行更新

>>> temp=(1, 2, 4, 5)
>>> temp=temp[:2]+(3,)+temp[2:]
>>> temp
(1, 2, 3, 4, 5)

【6】单独赋值与范围赋值

>>> a = [1,2,3,4,5]
>>> a[0:2]
[1, 2]
>>> a[0:2] = [123] #范围赋值，如果是连续性赋值则可一对多
>>> a
[123, 3, 4, 5]
>>> a[0:2] = [1,2]
>>> a
[1, 2, 4, 5]
>>> a[0:2]
[1, 2]
>>> a[0:2] = '123'  #拆分
>>> a
['1', '2', '3', 4, 5]
>>> a[0:2:2]
['1']
>>> a[0:2:2] = '123' #不连续性赋，必须保持一对一。
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: attempt to assign sequence of size 3 to extended slice of size 1

>>> a[0:2:2] = '1'
>>> a
['1', '2', '3', 4, 5]