Python基础（1）——变量和数据类型[xiaoshun]

目录

 

1、变量

1.概述

Variables are used to store information to be referenced（引用）and manipulated（操做） in a computer program.

2.声明

 （1）命名规则

• 变量名只能是字母、数字或下划线的任意组合；
• 第一个不能是数字
• 关键字不能做为变量名

 （2）定义

name1 = 'Lu'
name2 = name1
name1 = 'MJJ'
print(name1, name2)

-->:
MJJ Lu

 （3）删除

name1 = 'Lu'
del name1
print(name1)

-->:
NameError: name 'name1' is not defined

　变量的生命周期：无指向时，才会在内存中被回收。

2、数据类型

1.数字

 （1）分类

Python 支持三种不一样的数值类型：

• 整型(Int) ： 不带小数点。Python3 整型是没有限制大小的，能够看成   Long 类型使用，Python3 没有 Python2 的 Long 类型；
• 浮点型(float)：浮点型由整数部分与小数部分组成，浮点型也可使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）；
• 复数( (complex)) - 复数由实数部分和虚数部分构成，能够用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

 （2）类型转换

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。Python中复数不支持强转，但能够经过real和image方法获取到实部和虚部的值。

 （3）运算

不一样类型的数混合运算时会将整数转换为浮点数。

• /：老是返回一个浮点数。
• //：获得的并不必定是整数类型的数，它与分母分子的数据类型有关系。

　　　　　　　　　　7 // 2=3, 7.0 // 2=3.0,7 // 2.0=3.0

• **：幂运算。
• %：取余。

在交互模式中，最后被输出的表达式结果被赋值给变量 "_"。“_”应该为只读变量。

 （4）数学函数

• abs(x)：返回数字的绝对值，如abs(-10) 返回 10。
• max(x1, x2,...) ：返回给定参数的最大值，参数能够为序列。
• min(x1, x2,...) ：返回给定参数的最小值，参数能够为序列。
• pow(x, y)：x**y 运算后的值。
• sqrt(x) ：返回数字x的平方根。

 （5）随机数函数

2.字符串

（1）切片，索引，拼接

str[a:b],str[a:b:c]

• a,b为参数。从字符串指针为a的地方开始截取字符，到b的前一个位置（由于不包含b）；
• 若是a,b均不填写，默认取所有字符；
• 若是a填写，b不填写（或填写的值大于指针下标），默认从a开始截取，至字符串最后一个位置；
• 若是a不填写， b填写，默认从0位置开始截取，至b的前一个位置；
• 若是a为负数，默认从尾部某一位置，开始向后截取，最后一个位置为-1
• 若是a>=b, 默认输出为空。
• [a:b:c] 表示的是从头至尾，步长为c。第一个冒号两侧的数字是指截取字符串的范围,第二个冒号后面是指截取的步长。
• [::-1]：字符串倒序

万恶的字符串拼接：

　　python中的字符串在C语言中体现为是一个字符数组，每次建立字符串时候须要在内存中开辟一块连续的空，而且一旦须要修改字符串的话，就须要再次开辟空间，万恶的+号每出现一次就会在内从中从新开辟一块空间。

字符串是一种不可变数据类型，不能够改变。能够用截取的方式，拼接的方式从新组合成新的字符串。

　　　　　　　　　　　str1[0] = "H"

　　　　　　　　　　　TypeError: 'str' object does not support item assignment.

（2）转义

• \(在行尾时)：续行符。代码过长时，能够用续航符进行换行编写，且续行符以后，续行符后面什么都不能 出现（包括空格），必须换行（必须换行写内容）

　　　　　　　　a = "ajkfhajkfhkjahfkahfkhakfhkdafafafaddafafdafafadfafafafafafadefgg" \

　　　　　　　　　　"hfakjfhkah"

• \\ 反斜杠符号，\' 单引号，\" 双引号：

　　　　　　　　print(str1 + "\\")print("\'" + str1 + "\'")

• \a 响铃，命令行交互模式中能够实现。
• \b 退格(Backspace)，\000 空，\n 换行，等

（3）运算

• “+”：拼接
• “str*number”：重复输出number次str
• []：获取索引
• [:]:截取，切片，左闭右开
• in,not in :成员逻辑运算符
• R/r：原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符，引入文件路径时经常使用。

　　　　　　　　print(r"hello \' word!")

　　　　　　　　print("hello \' word!")

（4）格式化输出

　　%和format（）函数使用、f-string字面量格式化字符串，是新的格式化字符串的语法。

（5）字符串操做

• str.capitalize()，无参数，将字符串的第一个字符转换为大写，其他转换成小写。首字符为非字母，则不转换，其他转为小写。
• str.center(width[, fillchar])，返回一个指定宽度且原str居中的新字符串，fillchar 为填充的单个字符，默认为空格。

　　　　参数：width，宽度；fillchar，能且只能为一个字符。

　　　　注意：

　　　　　　a、若是 width 小于字符串宽度直接返回字符串，不会截断；

　　　　　　b、fillchar 只能是单个字符。

• str.count(sub[, start= 0][,end=len(string)])，统计子字符串sub里某个字符串出现的次数。可选参数为在字符串搜索的开始（默认为0）与结束位置（默认为len（string））。

str1 ='python' * 3
print(str1.count('p'))
print(str1.count('p', 1))   # 包含起始位置
print(str1.count('p', 1, -6))   # 不包含结束位置

-->:
3
2
1

　　

• str.join(sequence)，将序列seq中的元素以指定的字符串str链接返回一个新的字符串。

　　　　参数：seq，元组、列表、字典、字符串。字典只能链接键值key。

str1 = '\t'
str2 = 'python'
list1 = [i*2 for i in str2]
print(str1.join(str2))
print(str1.join(list1))

-->:
p	y	t	h	o	n
pp	yy	tt	hh	oo	nn

　　

• str.split(str="", num=string.count(str))，指定分隔符对字符串进行切片。经常使用做数据的分析提取。

　　　　参数：str，分隔符，默认为全部的空字符，包括空格、换行(\n)、制表符(\t)等；num，分割次数。默认为 -1, 即分隔全部，分割为 num+1 个子字符串。

　　　　返回值：元素为字符串的列表。

　　　　　　爬虫时，图片名获取：

url_str = "http://www.baidu.com/python/image/123456.jpg"
print(url_str.split('/')[-1])

-->:
123456.jpg

　　

• str.strip([chars])，移除字符串头尾指定的字符（默认为空格）或字符序列chars，返回新字符串。

　　　　注意：

　　　　　　a、该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

　　　　　　b、若是不带参数，默认是清除两边的空白符，例如：/n, /r, /t, ' '等

str1 = '\tpython\t' * 3
print(str1.strip())

-->:
python		python		python

　　

　　　　　　c、带有参数的时候，这个参数能够理解一个要删除的字符的列表，删除多个字符时，只要头尾有对应其中的某个字符即 删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止。

str1 = 'a111123\t132231b213321312==3213122132*31123132'
print(str1.strip('123ab\t'))
# 等价于
for i in str1:
    if i in '123ab\t':
        str1 = str1.strip(i)

-->:
==3213122132*

　　

• （待补充）

3.列表

（1）基况

　　列表元素类型能够不一致，和C数组不同（相似ndarray）。列表元素能够修改，因此作列表有关操做时，要注意原列表的元素是否被更改了（深浅拷贝！！！）。

list1 = [i for i in range(10)]
list2 = list1    # list2 = list1.copy()
print(list1, list2)
list2[0] = 100
print(list1, list2)

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

（2）基操

• 下标索引查找或者更改（列表可变）
• 截取、切片：[:]；间隔截取：[:::]
• 拼接组合：“+”；重复：“*”
• 成员逻辑判断：in；not in

（3）列表嵌套

不支持花切，只能分层操做。

list1 = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(list1[1:][:])
print(list1[[0], [0]])

-->:
TypeError: list indices must be integers or slices, not tuple
[[4, 5, 6], [7, 8, 9]]

（4）常见内建函数和列表方法

内建函数：

• len(list)，返回列表元素个数
• min/max(list)，返回列表最小值/最大值

　　　　元素所有为数字类型时，直接根据值的大小比较。当其中的元素所有为字符串类型(string)时，则比较的是每一个字符串元素的第一个字符的 ASCII 的大小。

• list(seq)，将元组或字符串转换成列表。

str1 = "python"
tup1 = ('1', '2', '3')
dict1 = {'a': 1, 'b': 2, 'c': 3}
print(list(str1))    # 每一个字符循环一遍，相似列表生成式
print(list(tup1))
print(list(dict1))    # 默认为KEY
print(list(dict1.values()))

-->:
['p', 'y', 't', 'h', 'o', 'n']
['1', '2', '3']
['a', 'b', 'c']
[1, 2, 3]

• enumerate(list),以（index, value）小元组形式返回列表的下标和下标对应的值。

list1 = [i for i in range(10)]
for index, value in enumerate(list1):
    print(index, value)

-->:
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9

• 待补充

list对象的方法：

• list.append(obj)，在列表末尾添加新的对象，返回值为None，修改原列表。倘若不但愿原列表被改，记得先copy()。

list1 = [i for i in range(10)]
list2 = list1.append(10)
print(list2, type(list2), list1)

-->:
None <class 'NoneType'> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

• list.count(obj)，返回某个元素在列表中出现的次数。不能够像str.count()指定搜索区间，搜索整个列表。
• list.extend(seq)，在列表末尾一次性追加另外一个序列中的多个值（用新列表扩展原来的列表），无返回值。list.append()的循环增强版。

　　　参数：
　　　　seq-- 能够是列表、元组、集合、字典，若为字典,则仅会将键(key)做为元素依次添加至原列表的末尾。

• list.index(x[, start[, end]])，返回X在列表中第一次匹配到的索引。若是没找到，则抛出异常！

　　　　参数：
　　　　x-- 查找的对象。
　　　　start-- 可选，查找的起始位置。
　　　　end-- 可选，查找的结束位置。

• list.insert(index, obj)，将指定对象插入列表的指定位置，无返回值，在原列表操做修改。

• list.pop([index=-1])，移除列表中的一个元素（默认最后一个元素，不能超过len(list)，不然抛异常！），而且返回该元素的值。在原列表操做删除。
• list.remove(obj)，移除列表中某个值的第一个匹配项，无返回值。在原列表操做删除。没法指定匹配区间。

　　　　删除重复元素，不要用由前到后for循环。由于删除一个后，后面的元素回向前补齐，而循环下标仍是会正常加1，会致使后面的循环下标与元素不对应。
　　　　　　方法一：从后往前[::-1]循环开始删除。

　　　　　　方法二：用Python原生态方法，现用set（）列表变成集合（集合惟一性），再用list（）将集合变成列表。

list1 = [1, 2, 'a', 'l', 'a', 1, 1, 2, 3]
set1 = set(list1)
list1 = list(set1)
print(list1)

-->:
[1, 2, 3, 'l', 'a']

　　

• ist.reverse()，翻转180°，无返回值。
• list.sort( key=None, reverse=False)，排序。无返回值，原列表操做。默认reverse=False升序。
• 待补充

4.元组

（1）基况

　　与列表相似，但元素不能修改，又叫只读列表。和str同样，操做都会生成新的元组。

（2）基操

• 下标索引访问查找
• 截取、切片、间隔截取[:::]访问
• 拼接组合：“+”；重复：“*”
• 成员逻辑判断：in；not in

（3）常见内建函数及方法

函数：

• len（）、max（）、min（）
• tuple（iterable）：将可迭代系列转换为元组。

方法：（只有两个，由于元组不可变）

• count（）
• index（）

（4）元组注意事项

　　a、元组中只包含一个元素时，须要在元素后面添加逗号，不然括号会被看成运算符使用：

Tuple1 =（3）--》<class 'int'>Tuple = (3,)--》<class 'tuple'>

　　b、tuple的元素值是不容许删除的，但咱们可使用del语句来删除整个元组。

　　c、tuple中的“不变”，指的是“指向不变”，可是指向里面的内容是能够变的。

tuple1 = ([1, 2, 3, 9, 5], [1, 1, 2, 3], 100)
tuple1[0][0] = 100
print(tuple1)

-->:
([100, 2, 3, 9, 5], [1, 1, 2, 3], 100)

5.字典

（1）基况

　　字典是另外一种可变容器模型，且可存储任意类型对象。key-value键值对形式。

（2）键和值

• 键值必须惟一，值没必要，但同一个键值被赋值两次，后一次赋值会被记住；
• 值能够是任何数据类型（标准的、用户自定义的），但键值必须是不可变的数据类型：字符串、元组、数字；
• 对字典操做，通常经过键值（特殊的索引）进行操做：读取、修改、新增、删除等
• 经过键值对字典进行逻辑操做：key in/not in dict

（3）常见内建函数和方法

 函数：

• len（dict），计算字典元素个数，即键的总数。

方法：

• dict.clear()，清空字典内全部元素，字典不会被删除，无返回值无参数。
• dict.copy()，返回一个字典的浅拷贝。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict2 = dict1.copy()        # 深拷贝父对象（一级目录），子对象（二级目录）不拷贝，仍是引用
dict2['name'][0] = 'LU__'   # 子对象为引用
dict2['age'] = [100, 16]    # 父对象为拷贝
print(dict2)
print(dict1)

-->:
{'name': ['LU__', 'mjj'], 'age': [100, 16], 'sex': ['man', 'wom']}
{'name': ['LU__', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}

　　深拷贝须要用到copy模块的deepcopy()函数，copy.deepcopy(dict)

• dict.fromkeys(seq[, value])，建立一个值全同样的字典。不一样的key对应同样的value。

　　　　参数：

　　　　　　seq，序列中的元素为字典的键值

　　　　　　value，默认为None。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict2 = dict1.fromkeys('NAME')
dict3 = dict.fromkeys([1, 2, 3], [10, 10])
print(dict2)
print(dict3)
print(dict1)

-->:
{'N': None, 'A': None, 'M': None, 'E': None}
{1: [10, 10], 2: [10, 10], 3: [10, 10]}
{'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}

• dict.get(key, default=None)，返回指定键值对应的值，若是键值不在字典中返回默认值None。
• dict.items()，以列表形式（并不是直接的列表（dict_items迭代对象），若要返回列表值还需调用list函数）返回可遍历的(键, 值) 元组数组，参数无。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict1_item = dict1.items()
print(dict1_item)
print(type(dict1_item))
print(list(dict1_item))
print(list(dict1))  # 只获得键值列表
for i, j in dict1_item:
    print(i, j)

-->:
dict_items([('name', ['lu', 'mjj']), ('age', [18, 16]), ('sex', ['man', 'wom'])])
<class 'dict_items'>
[('name', ['lu', 'mjj']), ('age', [18, 16]), ('sex', ['man', 'wom'])]
['name', 'age', 'sex']
name ['lu', 'mjj']
age [18, 16]
sex ['man', 'wom']

• dict.keys()，返回一个可遍历可迭代对象dict_kys，可使用 list() 来转换为列表。参数无，返回一个迭代器。pthon2.x直接返回一个列表。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
for i in dict1.keys():
    print(i)

• dict.setdefault(key, default=None)，和 get()方法 相似, 若是键不已经存在于字典中，将会添加键并将值设为默认值。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
print(dict1.setdefault('name'))
print(dict1.setdefault('birthday', ['1995-8-6', '1995-3-9']))
print(dict1)

-->:
['lu', 'mjj']
['1995-8-6', '1995-3-9']
{'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom'], 'birthday': ['1995-8-6', '1995-3-9']}

• dict.update(dict2)，把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里，无返回值。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict2 = {'birthday': ['1995-8-6', '1995-3-9']}
print(dict1.update(dict2))
print(dict1)

-->:
None
{'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom'], 'birthday': ['1995-8-6', '1995-3-9']}

• dict.values()，返回一个迭代器，可使用 list() 来转换为列表，列表为字典中的全部值。
• pop(key[,default])，删除字典给定键 key 所对应的值，返回值为被删除的值，并修改原字典。key值必须给出。 不然，返回default值。
• popitem()，返回并删除字典中的最后一对键和值。返回一个键值对(key,value)形式，无参数。

6.集合

集合（set）是一个无序的不重复元素序列。两个重要做用：
　　去重：把列表变成集合便可
　　关系测试：测试两组数据以前的交集、差集、并集等

8.byte

字节流。有些时候（网络通讯）参数传递必须以字节流形式传参。

• str.encode()，编码，str to byte。
• b.decode()，解码，byte to str。

9.json