#! /d/soft/python3/python.exe
""" Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。
等号(=)用来给变量赋值。
等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。
允许你同时为多个变量赋值
为多个对象指定多个变量
"""
from cmath import sqrt
from random import random, randrange, shuffle, uniform
from secrets import choice
import site
from winreg import DeleteValue
counter = 1
miles = 1000.0
name = 'hjj'
print(counter)
print(miles)
print(name)
a = b = 1
print(a)
print(b)
a, b = 1, 2
print(a)
print(b)
"""
Python3 中有六个标准的数据类型:
Number(数字)
String(字符串)
List(列表)
Tuple(元组)
Set(集合)
Dictionary(字典)
Python3 的六个标准数据类型中:
不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)
"""
'''
Python3 支持 int、float、bool、complex(复数)。
在Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
像大多数语言一样,数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。
'''
# 输出类型
a, b, c, d = 20, 3.4, True, 3+2j
print(type(a))
print(type(b))
print(type(c))
print(type(d))
# 判断类型
print(isinstance(a, int))
'''
isinstance 和 type 的区别在于:
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
'''
'''
Python3 中,bool 是 int 的子类,True 和 False 可以和数字相加, True==1、False==0 会返回 True,但可以通过 is 来判断类型
'''
print(issubclass(bool, int))
print(True == 1)
print(False == 0)
print(True + 1)
print(False + 1)
print(1 is True)
print(0 is False)
# 删除变量
del a, b, c
# 数值运算
'''
1、Python可以同时为多个变量赋值,如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符:/ 返回一个浮点数,// 返回一个整数。
4、在混合计算时,Python会把整型转换成为浮点数。
'''
print(5 + 1)
print(5 - 1)
print(5 * 1)
print(5 / 3)
print(5 // 3) # 浮点数
print(5 % 2)
print(5 ** 2)
# 字符串(略)
# 列表
"""
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表
加号 + 是列表连接运算符,星号 * 是重复操作
"""
list = ['a', '123', True, 20.2]
tinyList = [123, 'hjj']
print(list)
print(list[0])
print(list[1:3])
print(list[2:])
print(list[0:-1])
print(list[0::2])
print(list + tinyList)
print(tinyList * 2)
# 与Python字符串不一样的是,列表中的元素是可以改变的
list[0] = 'b'
print(list)
list[0:2] = []
print(list)
# 元组 字符串是特殊的元组
"""
string、list 和 tuple 都属于 sequence(序列)。
注意:
1、与字符串一样,元组的元素不能修改。
2、元组也可以被索引和切片,方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。
"""
tuple = ('abc', 123, 3.22, True, False, "hjj")
tinyTuple = ('123', 'aaa')
print(tuple)
print(tuple[0])
print(tuple[1:3])
print(tuple[1:])
print(tuple[1::2])
print(tinyTuple * 2)
print(tinyTuple + tuple)
tupleEmpty = ()
tuple20 = (20, )
print(tupleEmpty)
print(tuple20)
"""
字符串:不可修改,可切割 '' "" * + [::]
元组:不可修改,可切割 () * + [::]
列表:可修改,可切割 [] * + [::]
"""
# 集合 有序
sitesEmpty = {}
print(sitesEmpty)
sites = set({1,2,3,4})
print(sites)
sites = {'baidu', 'google', 'bing', 'baidu'}
print(sites) # 过滤掉重复的值
if 'bing' in sites:
print('bing in')
else:
print('bing not in')
# 集合运算
a = set({'bb', 'nan', 'game', 'home'})
b = set({'jie', 'ge', 'game', 'home'})
print(a - b) # 差集,取a的不同
print(a | b) # 并集
print(a & b) # 交集
print(a ^ b) # a 和 b 不同时,存在的元素
# 字典
"""
1、字典是一种映射类型,它的元素是键值对。
2、字典的关键字必须为不可变类型,且不能重复。
3、创建空字典使用 { }。
"""
dictEmpty = {}
print(dictEmpty)
dictData = {}
dictData[0] = 'name'
dictData[1] = 'sex'
dictData['lang'] = 'ch'
print(dictData)
tinyDict = {'name': 'hjj', 'sex': 1}
print(dictData['lang'])
print(tinyDict.keys())
print(tinyDict.values())
tName = ('name', 'hjj')
tSex = ('sex', 1)
tLang = ('lang', 'ch')
lData = [tName, tSex, tLang]
dData = dict(lData)
print(dData)
print(dict(a=1,b=2,c=3))
# 推导
tDict = {x: x**2 for x in (2, 4, 6)}
print(tDict)
# 类型转换
"""
隐式类型转换 - 自动完成, # 验证过不会自动转换,需要主动转换成可转换的指定类型。
显式类型转换 - 需要使用类型函数来转换
"""
n = 1
m = 1.1
print(n+m)
s = '1.2'
# s = '111'
# print(s+n) # 无法相加
# print(int(s)+n) # 会报错
print(float(s)+n)
print(str(n) + s) # 拼接
# 函数
# number
a = -1
print(abs(a))
import math
print(math.ceil(9.1)) # 向上取整
print(math.floor(9.9)) # 向下取整
print(abs(-1.001))
print(math.fabs(-1.001))
print(min(1, 2))
print(max(1, 2))
print(pow(2, 8))
print(round(2.333, 2))
print(sqrt(9)) # complex
# 随机数
print(choice(range(10)))
print(randrange(0, 20, 2))
print(random())
print(int(random() * 10))
listData = [1,2,3,4,5]
shuffle(listData)
print(listData)
print(uniform(1, 100))
print(int(uniform(1, 100)))
print(math.pi)
print(math.e)
# 字符串 f-string f'{val}'
name = 'hjj'
print(f'Hello {name}')
print(f'{1+2}')
print(f'{1+2=}')
w = {'name': 'hjj', 'url': 'www.baidu.com'}
print(f'{w["name"]} {w["url"]}')
print(str.capitalize('HELLO WORLD'))
print(str.center('Game End', 10))
print(str.count('abc aab acc add', 'b'))
strings = '''
a b c
'''
print(str.endswith('ba', 'a'))
print(str.expandtabs(strings, 2))
print(str.find(strings, 'aa')) # 返回index / -1
print(str.index(strings, 'b')) # 返回index / 报错
# strings = '''aaa@123'''
# strings = '''aaa 123'''
strings = '''aaa打123'''
print(str.isalnum(strings)) # 至少有一个字符,并且所有字符都是字母或者数字
strings = '''a打d'''
print(str.isalpha(strings)) # 至少有一个字符,并且所有字符都是字母或者中文字
strings = '123'
print(str.isdigit(strings)) # 数字
strings = 'abc'
print(str.islower(strings)) # 全小写
strings = 'ABC'
print(str.isupper(strings)) # 全大写
strings = '123'
print(str.isnumeric(strings)) # 全数字
strings = ' '
print(str.isspace(strings)) # 包含空白,必须是全部空白
strings = str.title('hjj') # 首字母大写
print(strings)
print(str.istitle(strings)) # 是否标题化
print(len(strings))
strings = 'ccc bbb aaa'
print('@'.join(strings))
strings = 'c'
print(strings.ljust(10, '1')) # 左对齐并且填充1到10位
strings = ' abc'
print(strings.lstrip())
print(str.maketrans('a', 'b'))
strings = 'abc'
print(max(strings))
print(min(strings))
strings = 'abc '
print(max(strings))
print(min(strings)) # 空格是最小字符串
strings = 'this is a iii '
print(strings.replace('i', 'b', 2)) # 替换
strings = 'HELLO world'
print(strings.swapcase()) # 替换
print(strings.split(' '))
strings = '''a
b
c d e
'''
print(strings.splitlines()) # 换行合并
strings = 'a, b, c'
# print( strings.translate() )
strings = 'abc'
print(';'.join(strings))
tupleData = ('a', 'b', 'c')
print(';'.join(tupleData))
tupleData = ['a', 'b', 'c']
print(';'.join(tupleData))
tupleData = {'a', 'b', 'c'}
print(';'.join(tupleData))
tupleData = (1, 2, 3) # 数字要循环转换后才行,不然报错
print(';'.join(str(i) for i in tupleData ))
l1 = [1,2]
l2 = [1,2]
import operator
print(operator.eq(l1, l2))
l = [1,2,3,4,5]
t = ('1','2','3','4')
# print(list(t)) # 无法转换
print(len(l))
print(min(l))
print(max(l))
l.append(1)
print(l)
lo = ['a', 'b']
l.extend(lo)
print(l)
print(l.index('a'))
l.insert(1, 'after')
print(l)
l.remove(2)
print(l)
l.pop()
print(l)
l.reverse()
print(l)
def takeSecond(e):
return e
l = [1, 2, 3, 4, 5]
l.sort(key=takeSecond, reverse=False)
print(l)
l.sort(key=takeSecond, reverse=True)
print(l)
lc = l.copy()
print(lc)
l.clear()
print(l)
seq = ('a', 'b', 1)
d = dict.fromkeys(seq)
print(d)
d = {
"a": 1,
"b": 2,
"c": 3,
"d": {
"e": 4,
"f": {
"g": 5
}
}
}
print(len(d))
print(str(d))
dc = d.copy()
print(dc)
print( d.get('a'), d.get('z', 'zzz') ) # dict.get(key, 默认值)
print('a' in d)
print(d.items()) # 视图对象
print(d.keys()) # 视图对象
d2 = {'x': 1}
d.update(d2)
print(d)
dp = d.pop('a') # 返回值
print(dp)
print(d)
print(d.popitem()) # 返回对象
print(d)
cc = {}
def addOne(c):
if c in cc:
cc[c] += 1
else:
cc[c] = 1
addOne('a')
addOne('b')
addOne('a')
print(cc)
print(len(cc))
s = {
'a',
'b',
'c'
}
s.add('d')
print(s)
sc = s.copy()
print(sc)
sc.clear()
print(sc)
s.discard('d')
print(s)
s.remove('a')
print(s)
s.pop() # 随机移除
print(s)
s.update('z') # 新增
print(s)
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}
print(s1.difference(s2)) # 差集
s1.difference_update(s2) # 移除在s2中存在的元素
print(s1)
s1 = {1, 2, 3, 4, 5}
print(s1.intersection(s2)) # 交集
s1.intersection_update(s2)
print(s1)
s1 = {1, 2, 3, 4, 5}
print(s1.symmetric_difference(s2)) # 不重复的元素集合
s3 = {1}
print(s1.issuperset(s3)) # s3是否s1子集
# print(s3.isdisjoint(s1)) # 是否包含相同元素
print(s3.issubset(s1)) # s3是否s1子集
print(s1.union(s2)) # 并集
# 小结:
# 各种类型的方法和JS比较像. 和es6互相借鉴(抄袭)。有前端js基础的同学,更容易上手。
py-基本数据类型
最新推荐文章于 2024-08-15 10:59:23 发布
![](https://img-home.csdnimg.cn/images/20240711042549.png)