Python自动化第二周

基本数据类型

什么是数据类型？

数据类型就让计算机区分数字与字符串的区别，比如你想让计算机进行数值运算，那你就传数字给他，如果你想让他处理文字，就传字符串给他。但当你传入一个字母或者数字后如果不对其进行处理的话计算机是无法进行区分的例如（当你传入‘1’是数字，“汉”是汉字时，如果不明确告诉它的话它时分不清‘1’和‘汉’的区别的）而Python中常用的数据类型有多种常用的就三种下面就进行一一击破

整数类型

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

Long(长整型)

　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

Float(浮点型)

　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。

注意：在Python里不再有long类型，全是int

#!/usr/bin/env python  
# -*- coding: utf-8 -*-
a = 2**64
print(type(a))

<class 'int'>

 

a = 2**60
print(type(a))

<class 'int'>

字符串类型

在Pyhon中，加了引号的字符串都被认为是字符串

#!/usr/bin/env python  
# -*- coding: utf-8 -*-
age1 = "22"
age2 = 22
print(type(age1))
print(type(age2))

输出结果如下
<class 'str'>
<class 'int'>

可以很明显看出加引号的是str类型，而不加引号的为int类型。这里说到引号这里又涉及到单引号、双引号、多引号的区别。

这里首先说说什么时候用单引号什么时候用双引号

例如我有输出下面这段话

My name is yang , i’m 22 years old!

此时如果你用单引号的话，在执行过程中会报错

ABC = 'My name is yang , i'm 22 years old!'
print(ABC）

    ABC = 'My name is yang , i'm 22 years old!'

                                           ^
SyntaxError: invalid syntax

因为他会将'My name is yang , i'当作一个整体而后面的一串计算机便不认识所以便报错了

此时我们便涉及到用多引号此时再输出这段文字便不会出错了。

多引号，一般我们可以用多引号进行注释

'''
ABC = 'My name is yang , i'm 22 years old!'
'''
print(ABC)

此时输出ABC便不会有结果了，被多引号包裹的代码便不会执行，而多引号还有一个功能就是批量赋值如下，打印BBB便会显示出多引号里的内容

BBB = '''
My name is yang
i'm 22 years old
i am from china
'''
print(BBB)

字符串拼接

顾名思义就是将字符串进行拼接

name = 'yang'
age = '22'
print(name + age)
print(name * 3)

yang22

yangyangyang

注意字符串只能进行‘加’和‘相乘’运算

还有一点就是字符串拼接只能是双方都是字符串，不能和其他类型拼接

例如还是上面的例子

name = 'yang'
age = 22
print(name + age)

我把22的单引号去掉，然后执行这个脚本

TypeError: must be str, not int

它便会must be str ,not int的错误

布尔值（True,False）

布尔值就两值1或0  True（真）和False（假），主要用于逻辑判断

>>> a=3

>>> b=5

>>>

>>> a > b #不成立就是False,即假False>>>

False

>>> a < b #成立就是True, 即真

True

格式化输出

例如要输出如下内容
------------ info of yanghao -----------
Name  : yanghao
Age   : 23
job   : 运维
Hobbie: 大众爱好
---------------------------------------
代码如下
name = input('请输入名字：')
age = input('请输入年龄：')
job = input('请输入职业：')
hobbie = input('请输入爱好：')
msg = '''------------ info of %s -----------
Name  : %s
Age   : %d
job   : %s
Hobbie: %s
------------- end -----------------
''' % (name, name, age, job, hobbie)
print(msg)

%s就是代表字符串占位符，除此之外，还有%d,是数字占位符， 如果把上面的age后面的换成%d，就代表你必须只能输入数字啦

age: %d

你运行时会报TypeError: %d format: a number is required, not str的错误,说%d需要一个数字，但我们输入的是一个数字啊。其实很简单因为input默认接受的所有输入默认都是字符串格式，如果想让他不报错须进行转换

第一种方法可以在input前面加int进行转换

age = int(input('请输入年龄：'))

第二种方法可以在于字符串和变量关联的地方进行转换

 % (name, name, int(age), job, hobbie)

问题：现在有这么行代码

msg = "我是%s,年龄%d,目前学习进度为80%"%('金鑫',18)print(msg)

这样会报错的，因为在格式化输出里，你出现%默认为就是占位符的%，但是我想在上面一条语句中最后的80%就是表示80%而不是占位符，怎么办？

msg = "我是%s,年龄%d,目前学习进度为80%%"%('金鑫',18)print(msg)

这样就可以了，第一个%是对第二个%的转译，告诉Python解释器这只是一个单纯的%，而不是占位符。

字符串的索引与切片

索引即下标，就是字符串组成的元素从第一个开始，初始索引为0
AAA = '123456789'
print(AAA[2])
print(AAA[3])
print(AAA[4])
输出结果
3
4
5
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾尾）。
AAA = '123456789'
print(AAA[2:5])
print(AAA[0:])
print(AAA[0:-1])
print(AAA[0:5:2])
print(AAA[5:0:-2])

字符串常用方法

#全部字母大写
name = "my name is yang , i'm 22 years old!"
print(name.upper())   
输出结果
MY NAME IS YANG , I'M 22 YEARS OLD!

#全部字母小写
name = "My Name Is Yang , i'm 22 Years old!"
print(name.lower())
输出结果
my name is yang , i'm 22 years old!

#首字母大写
name = "my name is yang , i'm 22 years old!"
print(name.capitalize())      首字母大写
输出结果
My name is yang , i'm 22 years old!

#大小写翻转
name = "My name is Yang , i'm 22 years old!"
print(name.swapcase())
输出结果
mY NAME IS yANG , I'M 22 YEARS OLD!

#每个单词的首字母大写
name = "my name is yang , i'm 22 years old!"
print(name.title())
输出结果
My Name Is Yang , I'M 22 Years Old!

#移除字符串头尾指定的字符（默认空格）
name = "               my name is yang , i'm 22 years old!"
print(name.strip())
输出结果
my name is yang , i'm 22 years old!

#进行字符串进行切片，然后放入列表（默认为空格）
name = "my name is yang , i'm 22 years old!"
print(name.split())
输出结果
['my', 'name', 'is', 'yang', ',', "i'm", '22', 'years', 'old!']


ms = 'abcdefg'
a = ms.split('c')
print(a)
输出结果
['ab', 'defg']

#总长度为70切不够用-填充
name = "my name is yang , i'm 22 years old!"
print(name.center(70,"-"))
输出结果
-----------------my name is yang , i'm 22 years old!------------------


#默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
ms = '\t1312265789737'
a = ms.expandtabs()
print(a)
输出结果
        1312265789737


#统计数字或者字符串出现的个数
ms = '1312265789737'
a = ms.count("2")
print(a)
输出结果
2


可以进行切片查询
ms = '1312265789737'
a = ms.count("2",4,6)
print(a)
查询2出现的个数从下标为4到6的中间查找


#寻找字符串中的元素是否存在
方法一、
ms = 'abcdefg'
a = ms.find('c')
print(a)
输出结果
2
但如果找不到元素的索引便会返回-1

ms = 'abcdefg'
a = ms.find('l')
print(a)
-1

方法二、通过.index查询

ms = 'abcdefg'
a = ms.index("cd")
print(a）
输出结果，如果查询不到元素索引便会报错
2

#判断是否以某某某开头
ms = 'abcdefg'
a = ms.startswith("a")
b = ms.startswith("b")
print(a)
print(b)
输出结果
True
False

既然可以判断以某某某开头就可以判断以某某某结尾
通过endswith 判断是否以...结尾
b = ms.endswith("b")
这里就不一一演示了，且判断也可以进行切片操作

#进行字符串的替换
name = "my name is yang, i'm 22 years old!"
print(name.replace("yang","abc"))
输出结果
my name is abc, i'm 22 years old!

#format的三种玩法 格式化输出
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'

#is系列判断字符的组成
name='yanghao123'
print(name.isalnum())     #字符串由字母或数字组成
True
print(name.isalpha()) #字符串只由字母组成
False
print(name.isdigit())     #字符串只由数字组成
False

列表list

列表是python中的基础数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

定义列表

lis = ['a','b','c','d','e','f']

列表增

lis.insert(1,'dsadsa')
print(lis)
输出结果
['a', 'dsadsa', 'b', 'c', 'd', 'e', 'f']

append增加到最后
lis.append('aaaaaaa')
print(lis)
输出结果
['a', 'b', 'c', 'd', 'e', 'f', 'aaaaaaa']

迭代增加
lis.extend('qqq')
print(lis)
输出结果
['a', 'b', 'c', 'd', 'e', 'f', 'q', 'q', 'q']

 列表删

lis = ['a','b','c','d','e','f']
方法一、pop删除
lis.pop(2)
print(lis)
输出结果
['a', 'b', 'd', 'e', 'f']

方法二、del删除
lis = ['a','b','c','d','e','f']
del lis[3]
print(lis)
输出结果
['a', 'b', 'c', 'e', 'f']
del也可以进行切片删除
lis = ['a','b','c','d','e','f']
del lis[2:4]
print(lis)
输出结果
['a', 'b', 'e', 'f']

方法三、按元素去删除
lis = ['a','b','c','d','e','f']
lis.remove('c')
print(lis)
输出结果
['a', 'b', 'd', 'e', 'f']

方法四、清空列表
lis = ['a','b','c','d','e','f']
lis.clear()
print(lis)
输出结果
[]

列表改

方法一、
lis = ['a','b','c','d','e','f']
lis[2]= 'abc'
print(lis)
['a', 'b', 'abc', 'd', 'e', 'f']

方法二、
lis = ['a','b','c','d','e','f']
lis[2:3]= ['aaa','bbb']
print(lis)
输出结果
['a', 'b', 'aaa', 'bbb', 'd', 'e', 'f']

列表查

切片去查，或者循环去查。

其他操作。

count（数）（方法统计某个元素在列表中出现的次数）。

1 a = ["q","w","q","r","t","y"]

2 print(a.count("q"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）

1 a = ["q","w","r","t","y"]

2 print(a.index("r"))

sort （方法用于在原位置对列表进行排序）。

 reverse （方法将列表中的元素反向存放）。

1 a = [2,1,3,4,5]

2 a.sort()# 他没有返回值，所以只能打印a

3 print(a)

4 a.reverse()#他也没有返回值，所以只能打印a

5 print(a)

元组tupe

元组被称为只读列表，数据可以被查询，但不能被修改

定义元组

sz =（1，2，3）

sz = (1,2,3,4,5,6)
print(sz[0])
print(sz[-1])
print(sz[1:3])
print(sz[:-1])
print(sz[::-2])
print(sz[::-1])

sz = (1,2,3,4,5,6)
#可利用for循环查询
for i in sz:
    print(i)

#index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。
sz = ('a' ,'b','c','d',1,2,3)
print(sz.index('c'))
print(sz.index(3))


#count: 获取某元素在列表中出现的次数
sz = ('a' ,'b','c','d',1,2,3,'a','c')
print(sz.count('a'))
print(sz.count('c'))

字典dict

字典是key - value 的形式存储数据

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下

name = {'name1':'yang','name2':'oldboy','name3':'alex'}

字典增

方法一、
name = {'name1':'yang','name2':'oldboy','name3':'alex'}
name['name4'] = 'bbbb'
print(name)

{'name1': 'yang', 'name2': 'oldboy', 'name3': 'alex', 'name4': 'bbbb'}

#方法二、
name = {'name1':'yang','name2':'oldboy','name3':'alex'}
name.setdefault("YY",123213)
print(name)

#输出结果
{'name1': 'yang', 'name2': 'oldboy', 'name3': 'alex', 'YY': 123213}
#在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。

字典删

#方法一、
name = {'name1':'yang','name2':'oldboy','name3':'alex'}
name.pop('name3')
print(name)
#输出结果
{'name1': 'yang', 'name2': 'oldboy'}

 
#方法二、
#popitem随机删除 有返回值

#方法三、
#Clear清空

name = {'name1':'yang','name2':'oldboy','name3':'alex'}
name.clear()
print(name)

字典改

#方法一、
name = {'name1':'yang','name2':'oldboy','name3':'alex'}
names = {'name1':'qqq','cs':'bbb'}
names.update(name)
#将name所有的键值对覆盖添加（相同的覆盖，没有的添加）到names中
print(names)

#方法二、
name = {'name1':'yang','name2':'oldboy','name3':'alex'}
name['name2'] = 'aabb'
print(name)

字典查

#方法一
name = {'name1': 'yang', 'name2': 'oldboy', 'name3': 'alex'}
print(name['name1'])
#输出结果
yang
#如果没用就会报错，这样就体验不好了

#方法二
name = {'name1': 'yang', 'name2': 'oldboy', 'name3': 'alex'}
print(name.get("name9"))
None
#没有可以设定返回值

小知识点

dic = {'k1': 'hello', 'k2': 'word'}

# 遍历字典的key
for key in dic.keys():

    print(key)

# 遍历字典值
for value in dic.values():

    print(value)

# 遍历字典的key-value
for key, value in dic.items():

    print(key, value)

集合set

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

　　去重，把一个列表变成集合，就自动去重了。

　　关系测试，测试两组数据之前的交集、差集、并集等关系。

集合的创建

set1 = {'rj','bt','bg','ag'}

集合的增加

set1 = {'rj','bt','bg','ag'}
set1.add('aabb')
print(set1)
#输出结果
{'bg', 'aabb', 'bt', 'rj', 'ag'}

set1 = {'rj','bt','bg','ag'}
set1.update('aabb')  #迭代增加
set1.update([1,2,3]) 
print(set1)
#输出结果
{'b', 'rj', 'ag', 'a', 'bg', 'bt'}
{1, 2, 3, 'bt', 'rj', 'ag', 'bg'}

集合的删除

#remove删除一个元素
set1 = {'rj','bt','bg','ag'}
set1.remove('ag')
print(set1)

#pop随机删除一个元素
set1 = {'rj','bt','bg','ag'}
set1.pop()
print(set1)

#clear清空集合
set1 = {'rj','bt','bg','ag'}
set1.clear()
print(set1)

#删除集合
set1 = {'rj','bt','bg','ag'}
del set1
print(set1)

集合的其他操作

#交集（&  或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

#并集（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

# 差集。（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

#反交集。 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

#子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

#frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>