Python: 学习系列之二：基础介绍(int/float/string/range/list/tuple/dict/set)

系列

• Python: 学习系列之一：Python能做什么
• Python: 学习系列之二：基础介绍(int/float/string/range/list/tuple/dict/set)
• Python: 学习系列之三：基础介绍二
• Python: 学习系列之四：有趣的经典数学问题
• Python: 学习系列之五：类、继承、多态、封装
• Python: 学习系列之六：对象的内置函数及类对象的特殊方法
• Python: 学习系列之七：模块、PIPY及Anaconda
• Python: 学习系列之八：异常的处理
• Python: 学习系列之九：文件读写
• Python: 学习系列之十：函数

简介

1. 重点：被纳入高考，上升到了国家战略的层面上

2. 优点：大量的第三方库
3. 缺点：Python是解释型语言，所以慢
4. 适用范围：网络应用，包括网站、后台服务、机器算法、大数据等
5. 代码易被偷：解释型的语言，则必须把源码发布出去
6. 运行Python：Python解释器（就是负责运行Python程序的）
7. 编辑器：Pycharm

基础知识

• Python中的语句不需要使用任何符号作为结束符
• 打印：print() 自带换行, 或者print('hello,world',end='') 不换行
• 单行注释用#，多行注释，将多行代码包含在三个引号中。
• 变量是没有数据类型的，只有对象才有数据类型，通常，一个变量只引用一种数据类型的对象。
• 在Python中代码块开始于冒号，代码块中的所有行都要缩进相同的空格，一般是4个空格，使用Tab就可以了。

a=18 ; a ='hello';

整数

print(0b111) #二进制
print(0o111) #10进制
print(0x111) #16进制
print(bin(100)) #二进制
print(oct(100)) #10进制
print(hex(100)) #16进制
print(int(1))
print(int(2.1)) #取整
print(int('3')) #转整
# print(int('aa')) #报错
print(int('0b1100100',2)) # 100 ， 2为2进制

其它

print(type(5)) ; print(type(5.4))
print(type('hello'))

print(float(1.1))
print(2.3e3) # 2.3 * 10的三次方
print(1.1+2.2 -3.3)  #4.440892098500626e-16
print((1.1 +2.2)) #3.3000000000000003


from decimal import Decimal

print(Decimal('1.1') + Decimal('2.2') - Decimal('3.3')) #0.0

from fractions import  Fraction
print(Fraction(11,10)+Fraction(22,10)-Fraction(33,10)) #0

print(True)
print(False  ==0) # True的值为1， False的值为0
print(True and False)
print(not False)

• is （is not） 用于比较两个运算数是否是同一个对象。

a=b=[1,2,3]; c=[1,2,3]; 
print(a==b) # True
print(a==c) # True
print(a is c)

•  不可变类型对象的is比较（可以使用id()查看内存地址）

#只有不可变对象才存在哈希值

a=18; b =18;
print(id(a));print(id(b));print(a is b);#True

•  比较运算符可用于链式比较

age=18; print(1<age <100)
print( 1 ==2 and 2<3)

• 变量、函数、方法、类等名字是区分大小写的。

对象None， 是占据内存空间的，它并不是为“空” 或“没有定义”，用于表示数据值的不存在。

print(id(None)) #通常用于对象的初始化，或者将变量重置为数据值不存在的状态
a=18
a =None

序列类型（range)

• range类型用于表示不可变的整数序列，它的优点在于:不管range对象有多长，此对象占用的内存空间都是相同的，它只会存start,stop,step，只有在用的时候，才会计算它的相关元素。

#创建的对象不包含stop
range(stop);print(list(range(5))) # [0,1,2,3,4]
range(start,stop);print(list(range(1,5))); # [1,2,3,4]
range(start,stop,step)

• 序列类型有:列表、元组、字符串，对于序列类型对象，我们可以使用in来检查序列类型是否包含某元素

print(3 in range(5))
print(8 not in range(5))

列表

• 列表中可以存在重复的数据
• 列表中可以保存任何类型的数据，多种类型的数据可以混用
• 使用列表时不须预先声明列表的容量

#list是列表对应的类名
a = ['python', 18, True]
print(type(a))
print([]) #空列表
print(list()) #空列表
print(list(range(5))) #构造函数

print(a.index(18)) # 1
print(a.index(18,start,stop)) 

print(a[0]) #python
print(a[-3]) #python

print(a[0:3:2]) #a[start:stop:step]

print(a[::-1]) #对列表进行的翻转

print(a[:100]) #切片是允许索引跨界的

print(a[slice(1,7,2)]) #它等于 a[1:7:2], slice(stop), slice(start,stop), slice(start,stop,step)

a[1:2]=[1,2,3,4,5,6] #为指定的切片赋值时，左右两边的个数可以不相同

a.append(8);
a.append([9,10]) #append一次只增加一个元素，这里会变成一个二维数据
a.extend([9,10]) #如果要一次性加多个元素，可以使用extend
a.insert(3,8) #索引为3的位置插8
a.insert(len(a),8) #相当于append

a.remove(5) # remove(value)
a.pop(3) # pop(index)，一次只删除一个元素，不指定索引的话，会删除最后一个元素。
del a[2]
a.clear() #清空所有元素

L1=[1,2];L2=[3,4];print(L1+L2); #[1,2,3,4]
L1=[1,2];L3 =L1*3;print(L3); #[1,2,1,2,1,2]

[2,3,8,6,7]< [2,3,,9,5,1] # true, 从左到右开始比较，相等继续比较，不相等时比较，后续的不再比较

a.reverse() #列表翻转,它等于reversed(a)

a.sort(); #升序 a.sort(reverse = True) #降序; sorted(a); sorted(a, reverse =True)

元组

元组(tuple)是不可变类型

print(())
print(tuple())
t= ('python',18,True)
t[1] = 20 #会报错，因为元组是不可变类型

t =(5,[1,3],8) 
t[1][0] =7 # (5,[7,3],8) 这是可以改的，元组里存入的是对象的引用。

#只包含一个元素的元组
t =(18)
print(type(t)) #<class, 'int'> 可以看出它不是一个元组
t=(18,) # 它是一个元组，元组中至少包含一个逗号，否则它会被看一个数学符号

a,b = (1, 2)
a,b = 3, 4
print(a,b) #3 4
a,*b,c=(1,2,3,4)
print(a,b,c) #1 [2, 3] 4

字符串

单引号，双引号都可以，但建议用单引号

"Hello"
'Hello'
str()
str(123) #转换为字符串
str(1.2)

#换行：\n (newline), 回车 \r (return)， 水平制表符  \t (tab)  退格：\b (backspace)

print("123\"") # 123"

#原始的字符串 r是raw的意思， 原始字符的最后一个字符不能是反斜杠
print(r"C:\\ Program Files");   #C:\\ Program Files

print('''这是一个
多行的
字符串''')   # 三个号可以弄成多弄字符串，里面既可以单引号，也可以有双引号。

字典

#字典中的元素是无序的，顺序不重要，重要的是键值对的对应关系
#字典中的key必须是不可变对象，系统会调用内置函数hash根据指定的key计算出value的存储位置，也就是哈希值，对于指定的key，为了保证每次计算出的哈希值是相同的，要求key必须是不可变对象。
#字典也可以根据需要动态地伸缩，无须预先声明容量

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
a = dict(name='cong', age=21)  # {'name': 'cong', 'age': 21}
a = dict([('name', 'cong3'), ('age', 22)])  # {'name': 'cong3', 'age': 22}
a = dict()
a = dict({})  # 和上面的相等
a = dict(dict(zip(range(3), 'ABC')))  # {0: 'A', 1: 'B', 2: 'C'}

a = dict.fromkeys([1, 2, 3])  # {1: None, 2: None, 3: None}
a = dict.fromkeys([1, 2, 3], 'cong')  # {1: 'cong', 2: 'cong', 3: 'cong'}

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
print(a['name'])  # cong,如果没有此Key的话变会报错
print(a.get('name'))  # cong,如果没有此Key会返回None
print(a.get('sex', '男'))  # 男，如果没有此Key会返回默认值

print('name' in a)  # True
print('sex' not in a)  # True

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
a['name'] = 'congcong'  # a ={'name': 'congcong', 'age': 20} , 一次只能改一个KEY对应的值
a['birthday'] = '2019-5-11'  # 增加一个键值对
a.update({'name': 'Jason', 'age': 30, 'sex': 'male'})  # a = {'name': 'Jason', 'age': 30, 'sex': 'male'} 一次可改多个Key对应的值
a.update([('name', 'Mike')])  # a = {'name': 'Mike', 'age': 30, 'sex': 'male'}，这里可将元组看作是一个键值对

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
print(a.pop('name'))  # cong,  a = {'age': 20}
print(a.pop('birthday', 'aaa'))  # aaa 是默认值，如果Key不存在变返回默认值

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
del a['name']  # 删除指定的Key

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
print(a.popitem())  # 随机删除某个key,并返回值, 因为字典中的key是无序的

a.clear()  # 清空字典

a = dict({'name': 'cong', 'age': 20})
a.setdefault('sex', 'male')  # 给key设置一个默认值
a.setdefault('age', '1')  # 给key设置一个默认值
print(a)  # {'name': 'cong', 'age': 20, 'sex': 'male'}
print('sex' in a)  # True

a = dict({'name': 'cong', 'age': 20})
print(list(a.keys()))  # ['name', 'age'], 获取所有的key
print(list(a.values()))  # ['cong', 20],获取所有的value
print(list(a.items()))  # [('name', 'cong'), ('age', 20)]
for k,v  in a.items():
    print(k,v)


print('my name is %s, age is %d' % (a['name'], a['age']))  # my name is cong, age is 20
print('my name is {}, age is {}'.format(a['name'], a['age']))  # my name is cong, age is 20
print('my name is {name}, age is {age}'.format_map(a))  # my name is cong, age is 20

集合

#集合中不可以存储重复的数据
#集合中的数据是无序的
#集合中的数据可以是任何不可变的类型，多种类型的数据可以混合存储在一个集合之中
#集合可以根据需要动态地伸缩，也就是说，系统会根据需要动态地分配和回收内存，因此，在使用前无须预先声明集合的容量

a = set(list([1, 2, 3, 4, 5, 5]))
print(a)  # 集合会去重

b = set([1, 2, 8])  # 1，2，8
print(b)

c = set('wucong')  # {'w', 'o', 'g', 'u', 'n', 'c'} 可以看到集合中的值是无序的
print(c)

d = set()
print(type(d))

print(b.issubset(a))  # True 是否子集
print(a.issuperset(b))  # True 是否超集
print(a.isdisjoint(b))  # False  是否没有交集
print(a.intersection(b))  # 1,2 求交集
print(a & b)  # 1,2 求交集, 与上面的等价
print(a.intersection_update(b))  # 返回值为None, 取交集后更新a, b为原来的值

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8
print(a.union(b))  # 并集 {1, 2, 3, 4, 5, 8}
print(a | b)  # 并集,与上面的方法一样
# 不存在方法union_update

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8
print(a.difference(b))  # {3, 4, 5} 差集
print(a - b)  # {3, 4, 5} 差集, 与上面的一样
print(a.difference_update(b))  # None, a={3, 4, 5},b = {8, 1, 2}  取差集后更新a, b为原来的值

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8

print(a.symmetric_difference(b))  # {3, 4, 5, 8} 对称差集, 是指求并集后除去交集的部分
print(a ^ b)  # {3, 4, 5, 8} 对称差集， 和上面的方法一样
print(a.symmetric_difference_update(b))  # None, a={3, 4, 5, 8},b = {8, 1, 2}  取对称差集后更新a, b为原来的值

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8
a.add(6)  # 增加一个元素,一次只能增加一个元素 {1, 2, 3, 4, 5, 6}
a.update({7, 8})  # 增加两个元素 {1, 2, 3, 4, 5, 6, 7, 8}
a.update([9, 10])  # 增加两个元素 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
a.update((11, 12))  # 增加两个元素 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

a = set(list([1, 2, 3, 4, 5, 5]))
a.remove(1)  # 一次只删除一个元素，如果指定的元素不存在，则抛出KeyError
# del a[2] # 不支持这个操作，TypeError: 'set' object doesn't support item deletion
a.discard(2)  # 一次只删除一个元素，也是删除指定的元素，如果指定的元素不存在，则不会抛出KeyError
print(a.pop())  # 删除任意一个元素,并返回被删除的元素
a.clear()  # 清空集合

# frozenset不可变集合，在多线程环境中非常有用，所以一般尽可能地用它
a = frozenset({1, 2})  # 不可变集合,它存在哈希值，可以作为字典的KEY，也可以作为set中的元素
a = frozenset(range(1, 5))  # frozenset({1, 2, 3, 4})
a = frozenset([1, 2, 3, 4])  # frozenset({1, 2, 3, 4})
a = frozenset((1, 2, 3, 4))  # frozenset({1, 2, 3, 4})
a = frozenset('wucong')  # frozenset({'o', 'c', 'n', 'w', 'g', 'u'})