Python基础(1)

标准数据类型

Python3 中常见的数据类型有:

  • Number(数字)
  • String(字符串)
  • bool(布尔类型)
  • List(列表)
  • Tuple(元组)
  • Set(集合)
  • Dictionary(字典)

Python3 的六个标准数据类型中:

  • 不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
  • 可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。

此外还有一些高级的数据类型,如: 字节数组类型(bytes)。

Number(数字)

Python 数字数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变数字数据类型的值,将重新分配内存空间。

数值类型

Python 支持三种不同的数值类型:

  • 整型(int) - 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
  • 浮点型(float) - 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x \(10^2\) = 250)
  • 复数( (complex)) - 复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。

数字类型转换

有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。

  • int(x) 将 x 转换为一个整数。
  • float(x) 将 x 转换到一个浮点数。
  • complex(x) 将 x 转换到一个复数,实数部分为 x,虚数部分为 0。
  • complex(x, y) 将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。

数字运算

对数的加减乘除都支持,只是一些点需要注意些:

  • 将任意两个数相除时,结果总是浮点数,即便这两个数都是整数且能整除的。
  • 书写很大的数时,可使用下划线将其中的数字分组,使其更清晰易读 universe_age = 14_000_000_000,Python并不会打印其中的下划线。
  • 可在一行代码中给多个变量赋值。x, y, z = 0, 0, 0
  • Python没有内置的常量类型,但一般会使用全大写指出某个变量视为常量,其值应该始终不变。

String(字符串)

在Python中,用引号括起来的都是字符串,其中的引号可以是双引号也可以是单引号。

字符串改方法

方法title()以首字母大写的方式显示每一个单词,即将每个单词的首字母都改为大写。

name = "ada lovelace"
print(name.title())
#打印结果:Ada Lovelace

字符串全部大写方法:name.upper() 字符串全部小写方法:name.lower()

格式化字符串

应用场景在字符串中使用变量的值。这种被称为f 字符串,Python 通过把花括号内的变量替换为其值来设置字符串的格式。
同时花括号内也能调用函数方法。

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(full_name)

访问字符串中的值

Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串,可以使用方括号 [ ] 来截取字符串,字符串的截取的语法格式如下:变量[头下标:尾下标]

List(列表)

列表是一系列按特定顺序排列的元素组成。元素之间没有任何关系。用方括号([ ])表示列表,用逗号分隔其中的元素。

列表非常适合于存储程序运行期间可能变化的数据集。

访问列表元素

列表是有序集合,访问列表任意元素,可指出列表的名称,再指出元素的索引,并将后者放入方括号内。

bicycles = ["trek", "cannondale", "redline", "specialized"]
print(bicycles[0].title())

列表与字符串的访问方式一样,索引顺序访问都是从0开始,逆序访问都是从-1开始。

元素的增删改

修改列表元素:

motorcycles = ["honda", "yamaha", "suzuki"]
motorcycles[0] = "ducati"

添加列表元素:

motorcycles.append("ducati")	#列表末尾添加元素
motorcycles.insert(0, "ducati")	#任意位置添加元素,该位置下的每个元素都右移一个单位

删除列表元素:

del motorcycles[1]	#根据索引,删除任意位置下的元素
element = motorcycles.pop()		#弹出末尾元素
element = motorcycles.pop(0)	#根据索引,弹出任意位置下的元素
motorcycles.remove("ducati")	#根据元素值,删除元素

注意事项:

  1. 删除一个元素,且不再使用它,使用del语句;删除元素还要继续使用它,使用pop()
  2. 方法remove()只能删除第一个指定的值,若要删除的值在列表中出现多次,需要循环删除

组织列表

使用方法sort()对列表永久排序:

cars = ["bmw", "audi", "toyota", "subaru"]
cars.sort()

使用方法sorted()对列表临时排序:
保留列表元素原来的排列顺序,同时以特定的顺序呈现它们。

sorted(cars)	#顺序打印元素
sorted(reverse = True, cars)	#逆序打印元素

倒着打印列表:
反转列表元素的排列顺序,使用方法 reverse(),可永久性的修改列表元素的排列顺序。

cars.reverse()	#反转打印

确定列表长度: 函数len()获悉列表长度

len(cars)	#4

遍历列表

nums = ["alice","david","carolina"]
for iter in nums:
    print(iter)

创建数值列表

1、简单使用range() 函数

for value in range(1, 5);
	print(value)

2、使用range() 创建数字列表

numbers = list(range(1, 6)) #使用list()将range()的结果直接转换为列表
print(numbers)

3、range() 指定步长

even_numbers = list(range(2, 11, 2))
print(even_numbers)
---------------------------
[2, 4, 6, 8, 10]

4、对数字列表的简单计算

digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(f"min(digits) = {min(digits)}\n")
print(f"max(digits) = {max(digits)}\n")
print(f"sum(digits) = {sum(digits)}\n")

5、列表解析

将for循环和创建新元素的代码合并成一行,并自动附加新元素

squares = [value ** 2 for value in range(1, 11)] #每取出一个元素,都会进行平方的操作
print(squares)

使用部分列表

1、切片,创建切片可指定要使用的第一个元素和最后一个元素的索引

players = ["charles", "martina", "michael", "florence", "eli"]

print(players[0:3]) #遵守左闭右开[?,?),不取右值
print(players[:4])	#若没有指定第一个索引,将自动从列表开头开始
print(players[:4])	#若没有指定第二个索引,则切片终止于列表末尾
print(players[-3:]) #输出倒数后3个元素

2、遍历切片,使用for循环

for iter in players[:3]:
    print(iter.title())

3、复制列表

复制列表可创建一个包含整个列表的切片,同时省略起始索引和终止索引。注意这里不是将副本进行赋值,二者是指向同一个列表。

players = ["charles", "martina", "michael", "florence", "eli"]
player1 = players[:]

Tuple(元组)

python将不能修改的值称为不可变的,而不可变的列表被称为元组。元组使用圆括号来标识。定义元组后,可使用索引来访问元组元素。

dimensions = (200, 50)
dimensions[0] = 250	#报错!

#TypeError: "tuple" object does not support item assignment(禁止修改元组)

严格来说,元组是由逗号标识的,圆括号只是让元组看起来更整洁清晰。如果要定义只包含一个元素的元组,必须在这个元素后面加上逗号。

my_t = (3,)

遍历元组

dimensions = (200, 50)
for iter in dimensions:
    print(iter)

修改元组元素

虽然不能修改元组的元素,但是可以给存储元组的变量赋值。如果需要存储的一组值在程序的整个生命周期内都不变,就可以使用元组。

dimensions = (200, 50)
dimensions = (400, 100) #更改元组的赋值

Dictionary(字典)

字典是一系列键值对。每个键都与一个值相关联。可以使用键来访问相关联的值。字典用在花括号 ({ }) 中的一系列键值对表示。

alien = {"color":"green", "points":5}

print(alien["color"]) #访问字典中的值

添加键值对

可依次指定字典名、用方括号括起来的键和相关联的值。

alien["x_position"] = 0   #添加键值对
alien["y_position"] = 25  #添加键值对
alien["x_position"] = 75   #修改键对应的值

alien_0 = {} #空字典
emptyDict = dict() #空字典

del alien_0["point"]  #删除键值对,彻底删除
alien.clear()     # 清空字典
del alien     	  # 删除字典

为避免在访问时指定的键不存在的问题,可使用get方法,返回一个默认值。

point_value = alien.get("points","No point value assigned.")

键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下实例:

tinydict = {['Name']: 'Runoob', 'Age': 7}
print ("tinydict['Name']: ", tinydict['Name'])
#----------------------------------------------------
Traceback (most recent call last):
  File "test.py", line 2, in <module>
    tinydict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

遍历字典元素

1、遍历所有键值对

for key, value in user_0.items(): #items() 返回的是一个键值对列表
    print(f"\nKey:{key}")
    print(f"Value:{value}")

2、遍历字典中的所有键

for name in language.keys(): #keys()返回的是一个列表,其中包含字典中的所有键
    print(name.title())

3、按特定顺序遍历字典中的所有键

for name in sorted(languages.keys()):
    print(f"{name.title()},thank you for taking the poll")

4、遍历字典中的所有值

for iter in languages.values():
    print(iter.title())

这种做法提取字典中所有的值,而没有考虑是否重复。若重复值太多,最终的列表可能包含大量重复项,为剔除重复项,可使用集合set,使得集合中的每个元素都是独一无二的。

for iter in set(languages.values()):
    print(iter.title())

Set(集合)

集合(set)是一个无序的不重复元素序列。集合中的元素不会重复,并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合,元素之间用逗号 , 分隔, 或者也可以使用 set() 函数创建集合。

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

元素的增删改

添加元素:

s = set(("Google", "Runoob", "Taobao"))
s.add( x )	#将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。

s.update( x )	#可以添加元素,且参数可以是列表,元组,字典等	
s.update({1,3})
print(thisset)
# {1, 3, 'Google', 'Taobao', 'Runoob'}

移除元素:

s.remove( x )	#将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
s.discard( x )	#移除集合中的元素,且如果元素不存在,不会发生错误

s.pop() 	#随机删除集合中的一个元素
#set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除。

s.clear()	#清空集合 s

判断元素是否在集合:

x in s	#判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。

集合操作

右全包含布尔真:判断 setx 集合的所有元素是否都包含在 sety 集合中

setx.issubset(sety):bool
>>> x = {"a", "b", "c"}
>>> y = {"f", "e", "d", "c", "b", "a"}
>>> x.issubset(y)
True

左全包含布尔真: 判断 sety 集合的所有元素是否都包含在原始 setx 的集合中

setx.issuperset(sety):bool
>>> x = {"a", "b", "c"}
>>> y = {"f", "e", "d", "c", "b", "a"}
>>> y.issuperset(x)
True

右半包含布尔取反:判断集合 sety 中是否有集合 setx 的任一元素(包含返回 False,不包含返回 True)

setx.isdisjoint(sety):bool

合并集合(并集):(注意:集合元素的去重、唯一性)

setx.union(sety [, setz...]):set
>>> x = {"a", "b", "c"}
>>> y = {"f", "d", "a"}
>>> z = {"c", "d", "e"}
>>> x.union(y, z) 
{'c', 'd', 'f', 'e', 'b', 'a'}

左包含差集: 返回集合的差集,即返回的集合元素包含在第一个集合 x 中,但不包含在第二个集合 y(方法的参数)中

setx.difference(sety):set

左引用删除交集(无返回值,即直接修改原内存指向)

setx.difference_update(sety):void
>>> x,y
({'banana', 'cshit', 'vipkwd.com', 'alipay'}, {'google', 'runoob', 'facebook', 'alipay'})>>> type(x.difference_update(y))
<class 'NoneType'>
>>> x,y
({'banana', 'cshit', 'vipkwd.com'}, {'google', 'runoob', 'facebook', 'alipay'})

左右差集:返回两个集合中不重复的元素集合,即会移除两个集合中都存在的元素

setx.symmetric_difference(sety):set

左引用删除交集且引用追加右差集(引用操作,无返回值)

setx.symmetric_difference_update(sett):void

左右交集:返回两个或更多集合中都包含的元素,即交集

setx.intersection(sety[, seyz....]):set

左引用交集

setx.intersection_update(sety):void

辅助理解:所有提到 “引用” 俩字的都是函数内部直接操作内存指向,故无返回值;反之:如果一个函数没有实质返回值,那么它一定是在函数内部改变了其他位置内容, 否则这个函数就是 dog shit,因为它不具有实质的意义。

热门相关:有个人爱你很久   神算大小姐   闺范   上神来了   上神来了