nsd1905_py01_day01

创建虚拟环境

python的虚拟环境，就是一个隔离的目录。将python放到这个隔离的目录，以后安装软件包都安装到这个虚拟环境。当虚拟环境不需要时，只要将其删除。

  1. [root@room8pc16 nsd2019]# python3 -m venv ~/nsd1905
  2. # 激活虚拟环境
  3. [root@room8pc16 nsd2019]# source ~/nsd1905/bin/activate
  4. (nsd1905) [root@room8pc16 nsd2019]# python --version
  5. Python 3.6.7
  6. (nsd1905) [root@room8pc16 nsd2019]# which python
  7. /root/nsd1905/bin/python

pycharm配置

py01_day01 - 图1

py01_day01 - 图2

选Skip Remaining

py01_day01 - 图3

Create New Project

py01_day01 - 图4

Location填写你的项目目录。再点击下面的Existing interpreter->右侧齿轮，点击add local

py01_day01 - 图5

勾选Make available….，再点击三个点那个按钮

py01_day01 - 图6

填写创建的虚拟环境的python。

调整编写代码文本的文字大小：File -> Settings

py01_day01 - 图7

同步代码

  1. 下载群共享里的压缩包并解压
  2. 进入nsd2019目录
  1. [root@room8pc16 nsd2019]# git pull  # 如果失败则执行以下命令
  2. # git pull https://github.com/MrZhangzhg/nsd2019.git

python的语法结构

  • python完全靠缩进表达代码逻辑
  • 顶层代码必须顶头写，不能有任何空格
  • 某个代码的子代码，必须有缩进，缩进多少都行，建议4个空格

print语句

  • print是函数，用于屏幕输出

input语句

  • input是函数，用于获取用户的键盘输入
  • input读入的数据都是字符类型的。相同类型的数据才能一起运算
  1. >>> a = input('number: ')
  2. number: 10
  3. >>> a + 5   # 报错
  4. >>> a + '5'   # 字符串拼接
  5. '105'
  6. >>> a + str(5)   # str用于将数据转成字符
  7. '105'
  8. >>> int(a) + 5   # int用于将字符类型的数字，转成整数
  9. 15

变量

  • 会变化的量
  • 字面量表示字面本身的含义，它不会改变。
  • 命名约定
    • 首字符，必须是字母或下划线
    • 其他字符，可以是字母、数字、下划线
    • 区分大小写
  • 推荐的命名方法
    • 变量名全部采用小写字母
    • 有意义 pythonstring
    • 简短 pystr
    • 多个单词间用下划线分隔 py_str
    • 变量名用名词,函数名用谓词(动词+名词) phone / update_phone
    • 类名采用驼峰形式 MyClass
  • 变量使用之前必须赋值，进行初始化
  • 变量赋值采用=，运算是自右向左进行

python之禅

  1. >>> import this
  2. The Zen of Python, by Tim Peters
  4. Beautiful is better than ugly.
  5. Explicit is better than implicit.
  6. Simple is better than complex.
  7. 美胜丑，明胜暗，简胜繁。

运算符

  • 数学运算符
  1. >>> 10 / 2   # 真正的除法
  2. 5.0
  3. >>> 5 / 3
  4. 1.6666666666666667
  5. >>> 10 // 2   # 只保留商
  6. 5
  7. >>> 5 // 3
  8. 1
  9. >>> 5 % 3   # 模运算，返回余数
  10. 2
  11. >>> divmod(5, 3)   # 同时得到商和余数
  12. (1, 2)
  13. >>> a, b = divmod(5, 3)
  14. >>> a
  15. 1
  16. >>> b
  17. 2
  18. >>> 2 ** 3   # 幂运算，2的3次方
  19. 8
  • 比较运算符
  1. >>> 5 > 3
  2. True
  3. >>> 5 == 5
  4. True
  5. >>> 5 != 5
  6. False
  7. >>> 10 < 20 < 30   # python支持连续比较
  8. True
  9. >>> 10 < 20 > 15   # 10 < 20 and 20 > 15
  10. True
  • 逻辑运算符
  1. >>> 10 < 15 and 20 > 10   # and 两边的结果全为真，最终才为真
  2. True
  3. >>> 10 > 15 and 20 > 10
  4. False
  5. >>> 10 > 15 or 20 > 10
  6. True
  7. >>> 10 > 15 or 20 < 10    # or两边的结果全为假，最终才为假
  8. False
  9. >>> 20 > 15
  10. True
  11. >>> not 20 > 15   # not取反，将真变假，假变真
  12. False

数据类型

数字

  • 没有小数点的整数
    • 布尔数，也认为是整数
    • True值为1，False值为0
  • 有小数点的浮点数
  1. >>> True + 1
  2. 2
  3. >>> False * 10
  4. 0
  • 整数有不同的进制表示方式
    • 没有任何前缀的数字为10进制
    • 0o或0O表示8进制
    • 0x或0X表示16进制
    • 0b或0B表示2进制
  1. >>> 11
  2. 11
  3. >>> 0o11
  4. 9
  5. >>> 0x11
  6. 17
  7. >>> 0b11
  8. 3
  9. >>> oct(10)   # 转为8进制
  10. '0o12'
  11. >>> hex(10)   # 转为16进制
  12. '0xa'
  13. >>> bin(10)   # 转为2进制
  14. '0b1010'
  15. >>> oct(0x100)   # 将16进制的100转为8进制
  16. '0o400'

字符串

  • 字符串必须使用引号引起来
  • 单引号、双引号没有区别
  1. >>> print('Hello World')
  2. Hello World
  3. >>> print("Hello World")
  4. Hello World
  5. >>> name = 'bob'
  6. >>> print('hello name')
  7. hello name
  8. >>> print('hello %s' % name)
  9. hello bob
  10. >>> print('%s: %s' % (name, 20))
  11. bob: 20
  • python支持3引号。3引号是3个连续的单引号或双引号，它可以保留用户的输入样式
  1. >>> words = '''hello
  2. ... world
  3. ... greet
  4. ... '''
  5. >>> print(words)
  6. hello
  7. world
  8. greet
  10. >>> words
  11. 'hello\nworld\ngreet\n'
  12. >>> danci = "hello\nhow\nare\nyou"
  13. >>> print(danci)
  14. hello
  15. how
  16. are
  17. you
  • 字符串切片
  1. >>> py_str = 'python'
  2. >>> len(py_str)
  3. 6
  4. >>> py_str[0]
  5. 'p'
  6. >>> py_str[5]
  7. 'n'
  8. >>> py_str[6]   # 报错，IndexError
  9. >>> py_str[-1]  # 负数，表示从右向左取
  10. 'n'
  11. >>> py_str[-6]
  12. 'p'
  13. >>> py_str[2:4]   # 取切片，起始下标包含，结束下标不包含
  14. 'th'
  15. >>> py_str[2:6]   # 取切片，下标超出范围不会报错
  16. 'thon'
  17. >>> py_str[2:60]
  18. 'thon'
  19. >>> py_str[2:]    # 结束下标不写，表示取到结尾
  20. 'thon'
  21. >>> py_str[0:2]
  22. 'py'
  23. >>> py_str[:2]   # 开头不写，表示从开头取
  24. 'py'
  25. >>> py_str[:]
  26. 'python'
  27. >>> py_str[::2]   # 第2个冒号后面的数字是步长值
  28. 'pto'
  29. >>> py_str[1::2]
  30. 'yhn'
  31. >>> py_str[::-1]   # 步长值为负，表示自右向左取
  32. 'nohtyp'
  • 字符串的拼接、重复、成员关系判断
>>> py_str + ' is cool.'
'python is cool.'
>>> '*' * 30
'******************************'
>>> '#' * 30
'##############################'
>>> py_str * 3
'pythonpythonpython'
>>> 't' in py_str   # t在字符串中吗？
True
>>> 'th' in py_str   # th在字符串中吗？
True
>>> 'to' in py_str   # to在字符串中吗？
False
>>> 'to' not in py_str  # to不在字符串中吗？
True

列表和元组

  • 列表和元组也是序列对象，字符串常用的方法，在它们上面同样适用
>>> alist = [10, 20, 'bob', 'alice']
>>> len(alist)
4
>>> alist[0]
10
>>> alist[2:]
['bob', 'alice']
>>> alist * 2
[10, 20, 'bob', 'alice', 10, 20, 'bob', 'alice']
>>> 20 in alist
True
>>> 'bob' in alist
True

>>> atu = (10, 20, 'bob', 'alice')   # 元组用()定义
>>> atu[0]
10
>>> atu[2:]
('bob', 'alice')
>>> len(atu)
4
>>> 'alice' in atu
True

# 元组相当于是静态的列表，一旦定义就不能再修改。
>>> alist[0] = 100
>>> alist
[100, 20, 'bob', 'alice']
>>> atu[0] = 100  # 报错

字典

  • 字典是无序的
  • 采用key: val对形式
>>> adict = {'name': 'bob', 'age': 22}
>>> len(adict)
2
>>> 'bob' in adict   # bob是字典的key吗？
False
>>> 'name' in adict   # name是字典的key吗？
True
>>> adict['name']    # 通过key取出value
'bob'

数据类型总结

按存储模型分类

  • 标量：不能包含其他数据。数字、字符串
  • 容器：可以包含其他数据。列表、元组、字典

按访问模型分类

  • 直接访问：数字
  • 顺序：字符串、列表、元组
  • 映射：字典

按更新模型分类

  • 不可变：数字、字符串、元组
  • 可变：列表、字典