Python基础任务1

时长：2天

1. 环境搭建

1.anaconda环境配置
2.解释器

在anaconda官网中找到下载界面，选择下载想要配置的python版本。

官网下载太慢，可以在清华大学开源软件镜像站里找到最新的安装包进行下载安装。https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/

关于Mac下成功安装Anaconda花了点时间，上面的程序安装完之后，在iTerm2中输入conda，会发现找不到该内容。

conda

zsh： command not found: conda

百度后找到解决办法：
原文链接：https://medium.com/@sumitmenon/how-to-get-anaconda-to-work-with-oh-my-zsh-on-mac-os-x-7c1c7247d896

1. 打开用户路径下的.bash_profile文件（该文件默认隐藏，快捷键“ command + shift + . ”可以显示出来）。
   
2. 用编辑器打开.bash_profile文件，复制里面的内容，再打开同级目录下的 .zshrc 文件，把复制的内容粘贴到文件末尾并保存。
   
   
3. 之后重新打开iTerm2，输入conda出现以下信息则表示安装成功。
   

还有其他的解决办法，比如pip install conda，或者在终端里打开.bash文件和修改.zshrc文件，但这两种方法都失败了。

通过pip install conda方法安装，仍然会显示错误，由于经验不足，逐渐老戴空白，双眼失焦，灵魂出窍。。

ERROR: The install method you used for conda--probably either `pip install conda`or `easy_install conda`
--is not compatible with using conda as an application.If your intention is to install conda as a standalone
 application, currentlysupported install methods include the Anaconda installer and the minicondainstaller.  
 You can download the miniconda installer fromhttps://conda.io/miniconda.html.

2. python初体验

1.print and input

如果要让Python打印出指定的文字，可以用print()函数，然后把希望打印的文字用单引号或者双引号括起来，但不能混用单引号和双引号。

print('This is task1.')
# 'This is task1.'

Python提供了input()函数，可以让用户输入字符串，并存放到一个变量里。

someStr = input()
# 等待用户输入内容，输入完成后不会有任何提示。
# 输入的内容是存放到name变量里了。可以直接输入name查看变量内容。

someStr
# '刚刚输入的内容'

3. python基础讲解

1.python变量特性+命名规则
2.注释方法
3.python中“：”作用
4.学会使用dir( )及和help( )
5.import使用
6.pep8介绍

1. 变量特性+命名规则

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，第一个字符必须是字母表中字母或下划线 _，其他的部分由字母、数字和下划线组成，对大小写敏感。

python中的保留字即关键字，我们不能把它们用作任何变量名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字。

import keyword
keyword.kwlist
# ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue',
#  'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 
# 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 
# 'return', 'try', 'while', 'with', 'yield']

2. 注释方法

确保对模块, 函数, 方法和行内注释使用正确的风格，Python中的注释有单行注释和多行注释。

# 这是一个注释
print("Hello, World!")

多行注释用三个单引号 ‘’’ 或者三个双引号 “”" 将注释括起来。

'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
print("Hello, World!") 

"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""
print("Hello, World!") 

我们还可以可以输出函数的注释。

def a():
    '''这是文档字符串'''
    pass
print(a.__doc__)

# 输出结果：
# 这是文档字符串

3.python中“：”作用

• 出现在函数定义语句末尾、if for while语句末尾，表示下面的代码块应当缩进，从属于if for while语句。

for i in range(10):
    print i #从属于for语句

• 出现在字典定义当中用于分开键和值。

d = {'a':97, 'b':98, 'c':99}

• 在切片中使用。

str = ['h', 'e', 'l', 'l', 'o']
str[1:3] #结果为 ['e','l']

4.学会使用dir( )及和help( )

dir()

1. 描述： 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

dir([object])
# object -- 对象、变量、类型。
# 返回模块的属性列表。

2. 实例

dir()      #  获得当前模块的属性列表
# ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']

dir([ ])   # 查看列表的方法
# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__',
# '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__',
# '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', 
# '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__',
# '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove',
# 'reverse', 'sort']

help()

1. 描述：help() 函数用于查看函数或模块用途的详细说明。

help([object])
# object -- 对象。
# 返回对象帮助信息。

2. 实例

help('sys')             # 查看 sys 模块的帮助
……显示帮助信息……
 
help('str')             # 查看 str 数据类型的帮助
……显示帮助信息……
 
a = [1,2,3]
help(a)                 # 查看列表 list 帮助信息
……显示帮助信息……
 
>>>help(a.append)       # 显示list的append方法的帮助
……显示帮助信息……

5.import使用

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。

import 语句
模块的引入
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：

import module1[, module2[,... moduleN]]
# 比如要引用模块 support，就可以在文件最开始的地方用 import support 来引入。

# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

# 以上实例输出结果：
Hello : Runoob

from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1[, name2[, ... nameN]]
# 例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：

from fib import fibonacci

这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。

from…import*语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *
# 这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
# 例如我们想一次性引入 math 模块中所有的东西，语句如下：

from math import *

6.pep8介绍

原文链接：http://legacy.python.org/dev/peps/pep-0008/

1. 空格是首选的缩进方式
2. 所有行限制的最大字符数为79
3. 推荐的风格是在二元运算符之后中断
4. 顶层函数和类的定义，前后用两个空行隔开
5. Python核心发布版本中的代码总是以UTF-8格式编码（或者在Python2中用ASCII编码）
6. 导入通常在分开的行，导入总是位于文件的顶部，在模块注释和文档字符串之后，在模块的全局变量与常量之前

# 推荐: 
import os
import sys

······

4. python数值基本知识

1.python中数值类型，int，float，bool，e记法等
2.算数运算符
3.逻辑运算
4.成员运算符
5.身份运算符
6.运算符优先级

1. Python3 中有六个标准的数据类型：

Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

Python3 的六个标准数据类型中：
不可变数据：Number（数字）、String（字符串）、Tuple（元组）；
可变数据：List（列表）、Dictionary（字典）、Set（集合）。

1. Number
   Python3 支持 int、float、bool、complex（复数）。

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
# 内置的 type() 函数可以用来查询变量所指的对象类型。
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

2. String
   Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]
# 索引值以 0 为开始值，-1 为从末尾的开始位置。

str = 'Runoob'
 
print (str)          # Runoob          输出字符串
print (str[0:-1])    # Runoo           输出第一个到倒数第二个的所有字符
print (str[0])       # R               输出字符串第一个字符
print (str[2:5])     # noo             输出从第三个开始到第五个的字符
print (str[2:])      # noob            输出从第三个开始的后的所有字符
print (str * 2)      # RunoobRunoob    输出字符串两次
print (str + "TEST") # RunoobTEST      连接字符串

Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

print('Ru\noob')
# Ru
# oob
print(r'Ru\noob')
# Ru\noob

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行。

注意：
1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
Python 没有单独的字符类型，一个字符就是长度为1的字符串。
4、Python中的字符串不能改变。向一个索引位置赋值，比如word[0] = 'm’会导致错误。

3. List
   List（列表） 是 Python 中使用最频繁的数据类型。
   列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
   列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
   和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
   索引值以 0 为开始值，-1 为从末尾的开始位置。

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # ['abcd', 786, 2.23, 'runoob', 70.2]                 输出完整列表
print (list[0])         # abcd                                                输出列表第一个元素
print (list[1:3])       # [786, 2.23]                                         从第二个开始输出到第三个元素
print (list[2:])        # [2.23, 'runoob', 70.2]                              输出从第三个元素开始的所有元素
print (tinylist * 2)    # [123, 'runoob', 123, 'runoob']                      输出两次列表
print (list + tinylist) # ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']  连接列表

与Python字符串不一样的是，列表中的元素是可以改变的，List 内置了有很多方法，例如 append()、pop() 等等。
注意：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
letters[1:4:2]
# ['b', 'c']

4. Tuple
   元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
   元组中的元素类型也可以不相同。

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
 
print (tuple)             # ('abcd', 786, 2.23, 'runoob', 70.2)                输出完整元组
print (tuple[0])          # abcd                                               输出元组的第一个元素
print (tuple[1:3])        # (786, 2.23)                                        输出从第二个元素开始到第三个元素
print (tuple[2:])         # (2.23, 'runoob', 70.2)                             输出从第三个元素开始的所有元素
print (tinytuple * 2)     # (123, 'runoob', 123, 'runoob')                     输出两次元组
print (tuple + tinytuple) # ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob') 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取，其实可以把字符串看成特殊的元组。

tup = (1, 2, 3, 4, 5, 6)
print(tup[0])
# 1
print(tup[1:5])
(2, 3, 4, 5)
tup[0] = 11  # 修改元组元素的操作是非法的

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

string、list 和 tuple 都属于 sequence（序列）。

注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

5. Set
   集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
   基本功能是进行成员关系测试和删除重复元素。
   可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}      输出集合，重复的元素被自动去掉
 
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
# Rose 在集合中


# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)         # {'b', 'a', 'c', 'r', 'd'}
print(a - b)     # {'b', 'd', 'r'}                             a 和 b 的差集
print(a | b)     # {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}    a 和 b 的并集
print(a & b)     # {'a', 'c'}                                  a 和 b 的交集
print(a ^ b)     # {'l', 'r', 'z', 'm', 'b', 'd'}              a 和 b 中不同时存在的元素

6. Dictionary
   列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
   字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
   键(key)必须使用不可变类型。
   在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
 
print (dict['one'])       # 1 - 菜鸟教程                                                输出键为 'one' 的值
print (dict[2])           # 2 - 菜鸟工具                                                输出键为 2 的值
print (tinydict)          # {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}   输出完整的字典
print (tinydict.keys())   # dict_keys(['name', 'code', 'site'])                       输出所有键
print (tinydict.values()) # dict_values(['runoob', 1, 'www.runoob.com'])              输出所有值

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 {}。

2. 算数运算符

3.逻辑运算

4.成员运算符

5.身份运算符

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
# 1 - a 和 b 有相同的标识


if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
# 2 - a 和 b 有相同的标识


# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
# 3 - a 和 b 没有相同的标识

if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")
# 4 - a 和 b 没有相同的标识

6.运算符优先级