|
|
|
|
公众号矩阵

只需七步!零基础入门Python变量与数据类型

Python支持多种编程范型,包括函数式、指令式、结构化、面向对象和反射式编程。它拥有动态类型系统和垃圾回收功能,能够自动管理内存使用,并且其本身拥有一个巨大而广泛的标准库。

作者:云朵君来源:数据STUDIO|2021-04-30 11:33

 

Python(英国发音:/ˈpaɪθən/ 美国发音:/ˈpaɪθɑːn/)是一种广泛使用的解释型、高级和通用的编程语言。Python支持多种编程范型,包括函数式、指令式、结构化、面向对象和反射式编程。它拥有动态类型系统和垃圾回收功能,能够自动管理内存使用,并且其本身拥有一个巨大而广泛的标准库。

Python有着范围广泛的基本数据类型。Python的一个非常有用方面就是容器类型的概念,容器有二种基本形式:序列和映射。有次序的序列类型是列表(动态数组)、元组和字符串。所有序列类型都是位置索引的(从0到长度?1),并且除了字符串,都可以包含任意类型的对象,在同一个序列中包括多种类型的对象。字符串和元组是不可变的,使得它们成为字典的键的完美候选者。在另一方面,列表是可变的,元素可以被插入、删除、修改、添加或就地排序。

本篇内容总结包括从变量、输入输出到数据类型的基本介绍和常用方法。

一、变量与类型转换

变量赋值

  1. >>> x=5 
  2. >>> x 

变量计算

  1. >>> x+2  # 两个变量的和 
  2. >>> x-2  # 两个变量的减法 
  3. >>> x*2  # 两个变量相乘 
  4. 10 
  5. >>> x**2 # 求变量的幂 
  6. 25 
  7. >>> x%2  # 变量的余数 
  8. >>> x/float(2) # 变量的除法 
  9. 2.5 

类型和类型转换

方法 说明
str() 5', '3.45', 'True' 字符串
int() 5, 3, 1 整数
float() 5.0, 1.0 浮点数
bool() True, True, True 布尔值

二、获取帮助

  1. >>> help(str) 

三、输入与输出

print

  1. >>> print("Hello world!"
  2.  
  3. >>> msg = "Hello world!" 
  4. >>> print(msg) 

Input

Input程序可以提示用户输入。所有输入都存储为字符串。

  • 提示输入值
  1. >>> name = input("What's your name? " 
  2. >>> print("Hello, " + name + "!"
  • 提示输入数字
  1. >>> age = input("How old are you? "
  2. >>> age = int(age) 
  3. >>> pi = input("What's the value of pi? "
  4. >>> pi = float(pi) 

四、字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。创建字符串很简单,只要为变量分配一个值即可。

  1. >>> my_string = 'thisStringIsAwesome'  
  2. >>> my_string 
  3. 'thisStringIsAwesome' 

字符串运算

  1. >>> my_string * 2   # 乘法 
  2. 'thisStringIsAwesomethisStringIsAwesome'  
  3. >>> my_string + 'Innit' # 拼接 
  4. 'thisStringIsAwesomeInnit'  
  5. >>> 'm' in my_string # 是否存在 
  6. True 
  7. # 索引从零开始  
  8. >>> my_string[3] 
  9. >>> my_string[4:9] 

字符串方法

  1. >>> my_string.upper()    # 字符串大写 
  2. >>> my_string.lower()    # 字符串小写 
  3. >>> my_string.count('w') # 计算字符串的元素 
  4. >>> my_string.replace('e''i') # 替换字符串元素 
  5. >>> my_string.strip()    # 去空格 

五、列表

列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型。

列表以特定的顺序存储一系列项目。列表允许将信息集存储在一个地方,无论只有几个项还是数百万项。列表是Python最强大的特性之一,新程序员可以很容易地访问它,它们将编程中的许多重要概念联系在一起。

使用方括号定义列表,使用逗号分隔列表中的各个项目。使用列表的复数名称,使您的代码更容易阅读。

  1. >>> a = 'is' 
  2. >>> b = 'nice' 
  3. >>> my_list = ['my''list', a, b] 
  4. >>> my_list2 = [[4,5,6,7], [3,4,5,6]] 
  5.  
  6. >>> users = ['val''bob''mia''ron''ned'

更改列表值

一旦定义了列表,就可以更改列表中的单个元素。这可以通过引用要修改的项的索引来实现。

  1. >>> users[0] = 'valerie' 
  2. >>> users[-2] = 'ronald' 

列表切片与索引

可以使用列表中的任何一组元素。根据列表中的元素的位置(称为索引)来访问它们,列表的一部分称为片。要切片列表,首先从您想要的第一个项目的索引开始,然后添加冒号和您想要的最后一个项目之后的索引。去掉列表开始处的第一个索引,去掉列表结束处的最后一个索引。

第一个元素的索引是0,第二个元素的索引是1,以此类推。

负索引指的是列表末尾的项。要获得特定的元素,请先写出列表的名称,然后在方括号中写出元素的索引。

  1. # 子集 
  2. >>> my_list[1]   # 选择索引1的项 
  3. >>> my_list[-3]  # 最后选择第三项 
  4. # 切片 
  5. >>> my_list[1:3] # 选择索引1和索引2上的项 
  6. >>> my_list[1:]  # 选择索引0之后的项 
  7. >>> my_list[:3]  # 选择索引3之前的项 
  8. >>> my_list[:]   # 复制my_list 
  9. # 子集的子集 
  10. >>> my_list2[1][0] 
  11. >>> my_list2[1][:2] 

列表运算

  1. >>> my_list + my_list 
  2. ['my''list''is''nice''my''list''is''nice']  
  3. >>> my_list * 2 
  4. ['my''list''is''nice''my''list''is''nice']  
  5. >>> my_list2 > 4 
  6. True 

列表方法

  1. >>> my_list.index(a)     # 获取项目的索引 
  2. >>> my_list.count(a)     # 计算一个项目 
  3. >>> my_list.append('!')  # 每次追加一个项 
  4. >>> my_list.remove('!')  # 删除一个项目 
  5. >>> del(my_list[0:1])    # 删除一个项目 
  6. >>> my_list.reverse()    # 反向列表 
  7. >>> my_list.extend('!')  # 添加一个项目 
  8. >>> my_list.pop(-1)      # 删除一个项目 
  9. >>> my_list.insert(0,'!')# 插入一个项目 
  10. >>> my_list.sort()       # 排序的列表 
  • 遍历列表

列表可以包含数百万个项,因此Python提供了一种有效的方法来遍历列表中的所有项。当设置一个循环时,Python每次从列表中取出一项,并将其存储在一个临时变量中,为该临时变量提供了一个名称。这个名称应该是列表名称的单数版本。

缩进的代码块构成循环体,在循环体中可以处理每个单独的项。任何没有缩进的行在循环结束后运行。

  1. >>> for bike in bikes: 
  2. ...     print(bike) 
  • 向列表中添加元素

可以将元素添加到列表的末尾。

  1. >>> bikes = []  
  2. >>> bikes.append('trek' 
  3. >>> bikes.append('redline'
  4. >>> bikes.append('giant'
  • 在特定位置插入元素

可以将它们插入到列表中的任何位置。

  1. >>> users.insert(0, 'joe'
  2. >>> users.insert(3, 'bea'
  • 删除元素

可以根据元素在列表中的位置或项的值删除元素。如果你通过一个项的值来移除它,Python只移除第一个具有该值的项。

  1. # 通过位置删除 
  2. >>> del users[-1] 
  3. # 通过值删除  
  4. >>> users.remove('mia'
  • 列表排序

方法的作用是永久地改变列表的顺序。sorted()函数返回列表的副本,保持原始列表不变。可以按字母顺序或反字母顺序对列表中的项目进行排序。还可以颠倒列表的原始顺序。

  1. # 永久地对列表进行排序 
  2. >>> users.sort() 
  3.  
  4. # 以反字母顺序永久地对列表进行排序 
  5. >>> users.sort(reverse=True
  6.  
  7. # 临时排序 
  8. >>> print(sorted(users)) 
  9. >>> print(sorted(users, reverse=True)) 
  10.  
  11. # 反向排序 
  12. >>> users.reverse() 
  • 列表推导式
  1. >>> squares = [x**2 for x in range(1, 11)] 

range()函数

可以使用range()函数有效地处理一组数字。range()函数默认从0开始,停止传递给它的数字下面的一个数字。可以使用list()函数来有效地生成大量的数字列表。

  • 打印数字0-1000
  1. >>> for number in range(1001): 
  2. ...    print(number) 
  • 打印数字1-1001
  1. >>> for number in range(1, 1001): 
  2. ...    print(number) 
  • 列出从1到100万的数字
  1. >>> numbers = list(range(1, 1000001)) 

简单统计

您可以在包含数字数据的列表上运行许多简单的统计数据。

最小值

  1. >>> ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77] 
  2. >>> youngest = min(ages) 

最大值

  1. >>> ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77] 
  2. >>> oldest = max(ages) 

求和

  1. >>> ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77] 
  2. >>> total_years = sum(ages) 
  3. >>> total_years 
  4. 557 

六、元组

元组与列表类似,但元组中的项不能被修改,即不可变数据类型。

  1. >>> dimensions = (1920, 1080) 

七、字典

字典存储在片段信息之间的建立联系。字典中的每一个项都是一个键-值对。当提供一个键时,Python将返回与该键相关联的值。可以循环遍历所有键-值对、所有键或所有值。

使用花括号来定义字典。使用冒号连接键和值,并使用逗号分隔单个键-值对。

  1. >>> alien = {'color''green''points': 5} 

获取字典值(查)

要获取单个键关联的值,需提供字典的名称,然后将键放在一组方括号中。如果需要的键不在字典中,就会出现错误。

还可以使用get()方法,如果键不存在,该方法将返回None,而不是错误。如果键不在字典中,还可以指定要使用的默认值。

  1. >>> print("The alien's color is " + alien['color']) 
  2. "The alien's color is green" 
  3. >>> alien_0 = {'color''green''points': 5} 
  4. >>> alien_color = alien_0.get('color'
  5. >>> alien_points = alien_0.get('points', 0) 
  6. >>> print(alien_color) 
  7. 'green' 
  8. >>> print(alien_points) 
  9. None 

添加一个新键值对(增)

可以在字典中存储任意数量的键值对,直到计算机内存耗尽为止。要向现有字典添加新的键-值对,请在方括号中给出字典的名称和新键,并将其设置为新值。

这还允许您从一个空字典开始,并在它们变得相关时添加键-值对。

  1. >>> alien_0 = {'color''green''points': 5} 
  2. >>> alien_0['x'] = 0 
  3. >>> alien_0['y'] = 25 
  4. >>> alien_0['speed'] = 1.5 
  5.  
  6. # 向空字典中添加新键值对 
  7. >>> alien_0 = {} 
  8. >>> alien_0['color'] = 'green' 
  9. >>> alien_0['points'] = 5 

修改字典值(改)

可以修改与字典中任何键相关联的值。为此,给出字典的名称并将键括在方括号中,然后为该键提供新值。

  1. >>> alien_0 = {'color''green''points': 5} 
  2. >>> print(alien_0) 
  3.   
  4. >>> alien_0['color'] = 'yellow'  
  5. >>> alien_0['points'] = 10 
  6. >>> print(alien_0) 

删除字典键值对(删)

您可以从字典中删除任何想要的键-值对。为此,请使用del关键字和字典名称,后跟方括号中的键。这将删除键及其关联值。

  1. >>> alien_0 = {'color''green''points': 5} 
  2. >>> print(alien_0) 
  3. >>> del alien_0['points'
  4. >>> print(alien_0) 

循环遍历字典

可以用三种方式循环遍历字典:可以循环遍历所有键-值对、所有键或所有值。字典只跟踪键和值之间的连接,它不跟踪字典中条目的顺序。如果希望按顺序处理信息,可以对循环中的键进行排序。

  • 循环变量所有键值对
  1. >>> fav_numbers = {'eric': 17, 'ever': 4} 
  2. >>> for name, number in fav_numbers.items(): 
  3. ...    print(name + ' loves ' + str(number)) 
  • 循环变量所有键
  1. >>> av_numbers = {'eric': 17, 'ever': 4} 
  2. >>> for name in fav_numbers.keys(): 
  3. ...     print(name + ' loves a number'
  • 循环变量所有值
  1. >>> av_numbers = {'eric': 17, 'ever': 4} 
  2. >>> for number in fav_numbers.values(): 
  3. ...     print(str(number) + ' is a favorite'
  • 按顺序循环遍历所有键
  1. >>> av_numbers = {'eric': 17, 'ever': 4} 
  2. >>> for name in sorted(fav_languages.keys()): 
  3. ...   print(name + ": " + language) 

列表中嵌套字典

  • 通过append()将字典嵌入列表
  1. # 建立一个空列表 
  2. >>> users = [] 
  3. # 创建一个字典,并将其嵌入到列表中 
  4. >>> new_user = { 
  5. ...     'last''fermi'
  6. ...     'first''enrico'
  7. ...     'username''efermi'
  8. ...     } 
  9. >>> users.append(new_user) 
  10. # 再创建另一个字典,并将其嵌入到列表中 
  11. >>> new_user = { 
  12. ...     'last''curie'
  13. ...     'first''marie'
  14. ...     'username''mcurie'
  15. ...     } 
  16. >>> users.append(new_user) 
  17. # 打印出列表中所有的信息 
  18. >>> for user_dict in users: 
  19. ...     for k, v in user_dict.items(): 
  20. ...         print(k + ": " + v) 
  21. ...   print("\n"
  • 直接定义一个字典列表
  1. >>> users = [ 
  2. ...     { 
  3. ...        'last''fermi'
  4. ...        'first''enrico'
  5. ...        'username''efermi'
  6. ...   },  
  7. ...   { 
  8. ...        'last''curie'
  9. ...        'first''marie'
  10. ...        'username''mcurie'
  11. ...   },  
  12. ... ] 
  13. # 打印所有users的信息 
  14. >>> for user_dict in users: 
  15. ...     for k, v in user_dict.items(): 
  16. ...         print(k + ": " + v) 
  17. ...   print("\n"

字典内嵌套列表

在字典中存储列表,允许将多个值与同一个键关联。

  1. # 为每个人存储多种语言。 
  2. >>> fav_languages = { 
  3. ...     'jen': ['python''ruby'], 
  4. ...     'sarah': ['c'], 
  5. ...     'edward': ['ruby''go'], 
  6. ...     'phil': ['python''haskell'], 
  7. ... } 
  8. # 显示每个人的所有回答。 
  9. >>> for name, langs in fav_languages.items(): 
  10. ...     print(name + ": "
  11. >>> for lang in langs: 
  12. ...     print("- " + lang) 

字典内嵌套字典

可以将一个字典存储在另一个字典中。在这种情况下,与键相关联的每个值本身就是一个字典。

  1. >>> users = { 
  2. ...     'aeinstein': { 
  3. ...         'first''albert'
  4. ...         'last''einstein'
  5. ...         'location''princeton'
  6. ...         }, 
  7. ...     'mcurie': { 
  8. ...         'first''marie'
  9. ...         'last''curie'
  10. ...         'location''paris'
  11. ...         }, 
  12. ... } 
  13. >>> for username, user_dict in users.items(): 
  14. ...     print("\nUsername: " + username) 
  15. ...     full_name = user_dict['first'] + " " 
  16. ...     full_name += user_dict['last'
  17. ...     location = user_dict['location'
  18. ...     print("\tFull name: " + full_name.title()) 
  19. ...     print("\tLocation: " + location.title()) 
  20.  
  21. Username: aeinstein 
  22.  Full name: Albert Einstein 
  23.  Location: Princeton 
  24.  
  25. Username: mcurie 
  26.  Full name: Marie Curie 
  27.  Location: Paris 

顺序字典 OrderedDict

标准的Python字典不会跟踪键和值的添加顺序,它们只保留每个键及其值之间的关联。使用OrderedDict可以保持键和值的添加顺序。

  1. >>> from collections import OrderedDict 
  2. # 存储每个人的语言。 
  3. # 跟踪最先响应的人。 
  4. >>> fav_languages = OrderedDict() 
  5. >>> fav_languages['jen'] = ['python''ruby'
  6. >>> fav_languages['sarah'] = ['c'
  7. >>> fav_languages['edward'] = ['ruby''go'
  8. >>> fav_languages['phil'] = ['python''haskell'
  9. # 按照输入的顺序显示结果 
  10. >>> for name, langs in fav_languages.items(): 
  11. >>>     print(name + ":"
  12. >>>     for lang in langs: 
  13. >>>         print("- " + lang) 
  14.  
  15. jen: 
  16. - python 
  17. - ruby 
  18. sarah: 
  19. - c 
  20. edward: 
  21. - ruby 
  22. - go 
  23. phil: 
  24. - python 
  25. - haskell 

【编辑推荐】

  1. 使用Python操作Oracle
  2. SQL Server 中Select into复制数据到新表
  3. 什么是数据中毒?如何防范攻击者的AI和ML攻击?
  4. 手把手教你用Scrapy爬虫框架爬取食品论坛数据并存入数据库
  5. 博睿数据DataView标准化指标管理,助力企业快速制定SLO
【责任编辑:武晓燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

数据湖与数据仓库的分析实践攻略

数据湖与数据仓库的分析实践攻略

助力现代化数据管理:数据湖与数据仓库的分析实践攻略
共3章 | 创世达人

8人订阅学习

云原生架构实践

云原生架构实践

新技术引领移动互联网进入急速赛道
共3章 | KaliArch

39人订阅学习

数据中心和VPDN网络建设案例

数据中心和VPDN网络建设案例

漫画+案例
共20章 | 捷哥CCIE

232人订阅学习

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微