Python学习——(数据类型及其常用函数)

# 浮点型转换为整型
print(int(12.36))  # 12

# 整型转换为浮点型
print(float(17))  # 17.0

# 浮点型转换为字符串
print(str(-9.63)) # -9.63

# 转换为布尔类型
# False的情况：

print(bool(0))
print(bool(0.0))
print(bool(""))
print(bool(''))
print(bool(())) 
print(bool([])) 
print(bool({}) 
print(bool(" "))

# 其他转为布尔类型的结果都是True

三、运算符

(一)算数运算符

(二)赋值运算符

a = 10

a = b = 10

(三)复合赋值运算符

(四)比较运算符

(五)逻辑运算符

四、输入输出

——相当于java的Scanner scanner = new Scanner(System.in);

(一)输出

name = 'zs'
age = 12
# %s代表的是字符串 %d代表的是数值
print('我的姓名为%s,年龄为%d' % (name, age))
# 我的姓名为zs,年龄为12

(二)输入

password = input('请输入姓名：')
print('您的姓名为：%s' % password)
# 请输入姓名：张三
# 您的姓名为：张三

五、各数据类型常用函数

(一)数值函数

1.绝对值abs(x)

print(abs(-9.6))  # 9.6

2.最大值max(x1,x2...)

print(max(32, -9, 89))  # 89

3.最小值min(x1,x2...)

print(min(32, -9, 89))  # -9

4.向上取整math.ceil(x)

print(math.ceil(-5.8), math.ceil(5.3))  # -5 6

5.向下取整math.floor(x)

print(math.floor(-5.8), math.floor(5.8))  # -6 5

6.返回e的x次幂math.exp(x)

print(math.exp(1))  # 2.718281828459045

7.返回x的整数部分与小数部分modf(x)

print(math.modf(9.6)) # (0.5999999999999996, 9.0)

8.x**y的值math.pow(x)

print(math.pow(2, 3))  # 8.0

9.四舍五入round(x)

print(round(-9.8), round(9.8))  # -10  10

10.求平方根math.sqrt(x)

print(math.sqrt(121))  # 11.0

11. 随机数random()

print(random())  # 0.7661687961118427
print(math.ceil(random() * 10))  # 3

12.从指定范围内随机挑选random.choice()

print(random.choice(range(100)))  # 96
print(random.choice([8, 5.6, -4, 55]))  # 5.6
print(random.choice('hello world'))  # e

13. 按指定基数递增的集合中获取一个随机数randrange ([start,] stop [,step])

# 从1~99内获取奇数
print(random.randrange(1, 99, 2))  # 93

# 从0~100之间获取随机数
print(random.randrange(100))   # 13

14. 将序列的所有元素随机排序shuffle()

list1 = [20, 8, 6, 77]
random.shuffle(list1)
print(list1)  # [77, 8, 20, 6]

15.三角函数

print(math.cos(0), math.cos(math.pi))  # 1.0 -1.0
print(math.sin(0))  # 0.0
print(math.tan(0))  # 0.0

(二)字符串函数

1.字符串取值取下标

string = 'hello'
print(string[1],string[2:4])  # e  ll

2.字符串长度

print(len('java hadoop'))  # 11

3.全部转为小写

print(str.lower('JAVA HADOOP'))  # java hadoop

4.全部转为大写

print(str.upper('java hadoop'))  # JAVA HADOOP

5.整个字符串首字母大写(字符串"标题化")

print(str.capitalize('JAVA HADOOP'))  # Java hadoop

6.单词首字母大写

print(str.title('java hadoop'))  # Java Hadoop

7.字符串大小写互转

print(str.swapcase('javA hadOOP'))  # JAVa HADoop

8.字符串填充

print(str.center('Java hadoop', 20, '*'))  # ****Java hadoop*****
print(str.ljust('Java hadoop', 20, '*'))  # Java hadoop*********
print(str.rjust('Java hadoop', 20, '*'))  # *********Java hadoop

9.判断子字符串在字符串中出现的次数

语法：str.count(sub, start= 0,end=len(string))

参数

sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

string = '****Java hadoop*****'
print(string.count('*'))  # 9
print(string.count('*', 3, 10))  # 1

10.判断字符串开头/结尾

string = '****Java hadoop*****'
print(string.startswith('/'))  # False
print(string.endswith('*'))  # True
print(string.endswith('*', 1, 4))  # True
print(string.endswith('*', 3, 6))  # False

11.判断子字符串是否包含在字符串中find(str,beg=0,end=len(string))

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

string = '****Java hadoop*****'
print(string.find('*',3,10))  # 3
print(string.rfind('*'))  # 19

12. 寻找字符串下标

与find方法一样，但是如果str不在字符串中会报异常

print(string.index('a'))  # 5
print(string.rindex('a'))  # 10

13.字符串指定拼接join

str1 = '-'
str2 = 'world'
print(str1.join(str2))  # w-o-r-l-d

14.字符串去除空格

print(str.strip('  java  '))   # java
print(str.lstrip('  java  '))  # java
print(str.rstrip('  java  '))  #   java

15.字符串中最大/最小的字母

print(max('zhello'),min('zhello'))  # z e

16.替换字符串中的内容

print(str.replace('hello', 'l', '*'))  # he**o

17.字符串分割

string2 = 'Java hadoop spark flink mysql'

# 以空格为分隔符
print(string2.split(' '))  # ['Java', 'hadoop', 'spark', 'flink', 'mysql']

# 以a为分隔符，分割2次
print(string2.split('a',2))  # ['J', 'v', ' hadoop spark flink mysql']

# 以a为分隔符
print(string2.split('a'))  # ['J', 'v', ' h', 'doop sp', 'rk flink mysql']

18.返回长度为 width 的字符串，原字符串右对齐，前面填充0

string = '****Java hadoop*****'
print(string.zfill(25))  # 00000****Java hadoop*****

(三)列表函数

1.列表取值取下标

list = ['java','hadoop','spark','flink']
print(list[1:3],list[-3:-2], list[2:])  
# ['hadoop', 'spark'] ['hadoop'] ['spark', 'flink']

2.列表拼接

list = ['java','hadoop','spark','flink']
list.append('flume')
print(list)  # ['java', 'hadoop', 'spark', 'flink', 'flume']

list1 = ['hello','world']
list += list1
print(list)  # ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']

list2 = [list,list1] # 类似二维数组
print(list2)  
# [['java', 'hadoop', 'flink', 'flume', 'hello', 'world'], ['hello', 'world']]

print(list2[0],list2[1][1])
# ['java', 'hadoop', 'flink', 'flume', 'hello', 'world'] world

list1.extend('oracle')
print(list1)  # ['hello', 'world', 'o', 'r', 'a', 'c', 'l', 'e']

list1.insert(3,'2233')
print(list1)  # ['hello', 'world', 'o', '2233', 'r', 'a', 'c', 'l', 'e']

3.删除列表元素

list = ['java','hadoop','spark','flink']
del list[2]
print(list)  # ['java', 'hadoop', 'flink', 'flume']

# 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.pop()
print(list1)  # ['java', 'hadoop', 'flink', 'flume', 'hello']

list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.pop(2)
print(list1)  # ['java', 'hadoop', 'flume', 'hello', 'world']

# 移除列表中某个值的第一个匹配项
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.remove('flume')
print(list1)  # ['java', 'hadoop', 'flink', 'hello', 'world']

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

4.判断列表内容是否一致

import operator
list1 = ['a', 'b']
list2 = ['a', 'b']
list3 = ['a']
print(operator.eq(list1, list2), operator.eq(list1, list3))  # True False

5.返回列表个数

list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
print(len(list1))  # 6

6.返回列表的最大/最小值

list1 = [-9, 6, 78, 5.2]
print(max(list1), min(list1))  # 78 -9

7.统计某个元素在列表中出现的次数

list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'java']
print(list1.count('java'))  # 2

8.判断列表元素的索引位置

list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'java']
print(list1.index('hadoop'))  # 1

9.列表元素反转

list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.reverse()
print(list1)  # ['world', 'hello', 'flume', 'flink', 'hadoop', 'java']

10.列表元素排序

list1 = [-9.4,-55,78,999]
list1.sort()
print(list1)  # [-55, -9.4, 78, 999]

11.清空列表list.clear

12.复制列表list.copy

(四)元组函数

1.元组的形式

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>

2.创建空元组

tup1=()

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>

3.访问元组中的元素与字符串相同，取下标

Python 表达式	结果	描述
tup[1]	'Runoob'	读取第二个元素
tup[-2]	'Weibo'	反向读取，读取倒数第二个元素
tup[1:]	('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')	截取元素，从第二个开始后的所有元素。
tup[1:4]	('Runoob', 'Taobao', 'Wiki')	截取元素，从第二个开始到第四个元素（索引为 3）。

4.判断元组的长度

tup1 = ('java','hadoop', 'spark', 'flume')
print(len(tup1))  # 4

5.判断元组内元素的最大/最小值

tup1 = ('java','hadoop', 'spark', 'flume')
print(max(tup1),min(tup1))  # spark flume

6.元组中的元素不能修改

(五)字典函数

d = {key1 : value1, key2 : value2, key3 : value3 }由键值对组合而成

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

1.访问字典的数据——通过键访问

# 返回指定键的值
dict1 = {'name':'zs', 'age':19}
print(dict1['name'])  # zs
# 如果dict1后面的键没有，会触发异常

# dict.get(key[, value]) 
# key -- 字典中要查找的键。
# value -- 可选，如果指定键的值不存在时，返回该默认值。

dict2 = {'name': 'zhangsan', 'age': 10, 'gender': '男'}
print(dict2.get('age'))  # 10
print(dict2.get('java'))  # None
print(dict2.get('hadoop', '没有这个值！'))  # 没有这个值！

# dict.setdefault(key, default=None)函数：当键值不存在，或默认添加到字典中
print(dict2.setdefault('java','键不存在'))  # 键不存在
print(dict2)
# {'name': 10, 'age': 10, 'gender': 10, 'java': '键不存在'}

# 嵌套字典
dict3 = {'name': {'name1': 'zs', 'name2': 'ls'}, 'age': {'age1': 18, 'age2': 19}}
print(dict3['name'])  # {'name1': 'zs', 'name2': 'ls'}
print(dict3.get('name', {}).get('name2'))  # ls
print(dict3.get('age', {}).get('age1'))  # 18

2.修改字典

dict1 = {'name':'zs', 'age':19}
dict1['name']='ls'
print(dict1)  # {'name': 'ls', 'age': 19}


dict2 = {'name': 10, 'age': 10, 'gender': 10}
dict2.update({'class': 'flink'})
print(dict2)
# {'name': 10, 'age': 10, 'gender': 10, 'class': 'flink'}

3.删除字典

dict1 = {'name':'zs', 'age':19}
del dict1['name'] # 删除键 'name'
print(dict1)  # {'age': 19}

dict1 = {'name':'zs', 'age':19}
dict1.clear()     # 清空字典
print(dict1)  # {}

dict1 = {'name':'zs', 'age':19}
del dict1         # 删除字典
print(dict1)


# pop(key[,default])
# key - 要删除的键
# default - 当键 key 不存在时返回的值

dict2 = {'name': 'zhangsan', 'age': 10, 'gender': 10}
element = dict2.pop('name')
print('删除的元素为：',element)  # 删除的元素为： zhangsan
print('删除后的字典为：',dict2)  # 删除后的字典为： {'age': 10, 'gender': 10}

dict2 = {'name': 'zhangsan', 'age': 10, 'gender': 10}
element = dict2.pop('java','不存在的key')
print('删除的元素为：',element)  # 删除的元素为： 不存在的key
print('删除后的字典为：',dict2)  # 删除后的字典为： {'name': 'zhangsan', 'age': 10, 'gender': 10}


# dict.popitem()
# 返回并删除字典中的最后一对键和值。

dict2 = {'name': 'zhangsan', 'age': 10, 'gender': 10}
dict2.popitem()
print('删除后的字典为：',dict2)  # 删除后的字典为： {'name': 'zhangsan', 'age': 10}

4.字典键的特性

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

dict1 = {'name': 'zs', 'name': 'ls'}
print(dict1)  # {'name': 'ls'}

2）键必须不可变，所以可以用数字，字符串或元组充当，但不可以用列表

dict1 = {1: 'zs', 'name': 'ls',['age']: 18}
print(dict1)
Traceback (most recent call last):
  File "*********", line 1, in <module>
    dict1 = {1: 'zs', 'name': 'ls',['age']: 18}
TypeError: unhashable type: 'list'

5.输出字典的长度

dict1 = {'name': 'zhangsan','age': 22,'gender': '男'}
print(len(dict1))  # 3

6.复制字典dict.copy()

7.创建新字典

seq = ('name', 'age', 'gender')
# 不指定值
dict2 = dict.fromkeys(seq)
print(dict2)  # {'name': None, 'age': None, 'gender': None}
# 指定值
dict2 = dict.fromkeys(seq, 10)
print(dict2)  # {'name': 10, 'age': 10, 'gender': 10}

8.判断键是否存在

dict2 = {'name': 'zhangsan', 'age': 10, 'gender': '男'}
if 'name' in dict2:
    print('键存在')
else:
    print('键不存在')  # 键存在

if 'name1' not in dict2:
    print('键不存在')
else:
    print('键存在')  # 键不存在

(六)集合函数

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1.集合可以自动去重

set1 = {'java','mysql', 'hadoop', 'spark', 'java'}
print(set1)  # {'java', 'spark', 'hadoop', 'mysql'}

2.集合之间的运算

a = set('afhduias')
b = set('afhyuias')
# a中有，b中没有
print(a - b)  # {'d'}
# a中没有,b中有
print(b - a)  # {'y'}
# 集合a或b中包含的所有元素
print(a | b)  # {'y', 's', 'd', 'f', 'h', 'a', 'i', 'u'}
# 集合a和b中都包含了的元素——交集
print(a & b)  # {'a', 'i', 'u', 'f', 's', 'h'}
# 不同时包含于a和b的元素
print(a ^ b)  # {'d', 'y'}

########################################################

# 元素包含在集合 a ,但不在集合 b
a = {'hello', 'world'}
b = {'hello', 'java'}
c = a.difference(b)
d = b.difference(a)
print(a, b)  # {'hello', 'world'} {'hello', 'java'}
print(c, d)  # {'world'} {'java'}

# difference_update直接在原来的集合中移除元素，没有返回值
a = {'hello', 'world'}
b = {'hello', 'java'}
a.difference_update(b)
print(a, b)  # {'world'} {'hello', 'java'}


########################################################
# 返回集合的交集
# intersection()——有返回值
# intersection()_update——没有返回值

#########################################################
symmetric_difference()

3.添加元素add()与update()

set1 = {'java','mysql', 'hadoop', 'spark'}
set1.add('flink')
print(set1)  # {'spark', 'mysql', 'java', 'hadoop', 'flink'}

set1 = {('java', 'mysql', 'hadoop', 'spark')}
set1.update({1, 2})
set1.update([1, 4], [2, 6])  
print(set1)  # {1, 2, 4, 6, ('java', 'mysql', 'hadoop', 'spark')}

4.删除集合中的元素

set1 = {'java', 'mysql', 'hadoop', 'spark', 'flink'}
set1.remove('mysql')

# 移除指定元素后顺序打乱
print(set1)  # {'spark', 'java', 'flink', 'hadoop'}

##########################################################
set1 = {'java', 'mysql', 'hadoop', 'spark', 'flink'}
print(set1)  # {'spark', 'mysql', 'java', 'hadoop', 'flink'}
set1.clear()
print(set1)  # set()

##########################################################

# difference_update直接在原来的集合中移除元素，没有返回值
a = {'hello', 'world'}
b = {'hello', 'java'}
a.difference_update(b)
print(a, b)  # {'world'} {'hello', 'java'}

##########################################################

# discard() 方法用于移除指定的集合元素。
set1 = {'java', 'mysql', 'hadoop', 'spark'}
set1.discard('java')
print(set1)  # {'hadoop', 'mysql', 'spark'}

set1 = {'java', 'mysql', 'hadoop', 'spark'}
set1.discard('oracle')
print(set1)  # {'mysql', 'java', 'spark', 'hadoop'}

##########################################################

# 随机移除一个元素
c = {'hello', 'java', 'hadoop'}
c.pop()
print(c)  # {'hadoop', 'hello'}

##########################################################
# 返回两个集合中不重复的元素集合——有返回值
a = {'hello', 'java', 'mysql'}
b = {'hello', 'world', 'java'}
print(a.symmetric_difference(b))  # {'mysql', 'world'}
print(a, b)  # {'mysql', 'hello', 'java'} {'hello', 'world', 'java'}


# 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中
a = {'hello', 'java', 'mysql'}
b = {'hello', 'world', 'java'}
a.symmetric_difference_update(b)  # 没有返回值
print(a)  # {'world', 'mysql'}

5.复制集合copy()

6.返回多个集合的并集union()

a = {'hello', 'java', 'mysql'}
b = {'hello', 'world', 'java'}
c = {'zs', 'ls', 'ww'}
d = a.union(b,c)
print(d)  # {'mysql', 'ls', 'ww', 'java', 'world', 'hello', 'zs'}

7.判断是否包含元素

# isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
a = {'hello1', 'world'}
b = {'hello', 'java'}
c = {'hello', 'java'}

# 判断集合b中是否有包含 集合a的元素
x = a.isdisjoint(b)

# 判断集合c中是否有包含 集合b的元素：
y = b.isdisjoint(c)

print(x, y)  # True False

#############################################################

a = {'hello', 'java'}
b = {'hello', 'world', 'java'}
# b是否包含a
print(a.issubset(b))  # True
# b是否完全包含a
print(a.issuperset(b))  # False

##############################################################