小白学代码第一天

注：本人写出来是为了让自己记得深刻，顺便可以给和我一样都是小白的人看（想学好还是看权威的大佬写的），至于大佬，请多多指教。

一、安装python

本人安装的是新版的，去官网下载安装，它这个只能安装在C盘上。

安装好后，按 Win+R 键，输入 cmd 调出命令提示符，输入 python:

然后回车，就会出现黑色窗口，输入python 

就可以看版本信息，我的完整窗口有 个人信息，所以就不截取全部。

也可以在开始菜单中搜索 IDLE，也可以按win+s或者win+q（我的是win10系统，搜索框没有出现界面）

打开就可以了 

二、集成开发环境（IDE：Integrated Development Environment）: PyCharm

安装教程网上学的

三、开始编译

1、第一个代码

不管哪个语言，第一个几乎都是hello world

print（“hello world！”）

就是这么简洁，运行结果就是

hello,world!

2、标识符

标识符就是你自己命名的

1、第一个字符必须是字母表中字母或下划线 _ 。

2、标识符的其他的部分由字母、数字和下划线组成。

3、标识符对大小写敏感。

4、因为我用的是python3，所以标识符可以用中文作为变量名，非 ASCII 标识符也是允许的。

3、关键字

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

import keyword
keyword.kwlist

我是在 python下运行的，至于pycharm，应该也行，然后就会运行出关键字

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']

4、数据类型

int整型

bool (布尔), 如 True。

float (浮点数), 如 1.23、3E-2

complex (复数),如i

5、字符串

Python 中单引号 ' 和双引号 " 使用完全相同

使用三引号(''' 或 """)可以指定一个多行字符串

转义符 \

反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行

按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is string

字符串可以用 + 运算符连接在一起，用 * 运算符重复

Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始

Python 中的字符串不能改变

Python 没有单独的字符类型，一个字符就是长度为 1 的字符串

字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

6、输入，输出

输入input（自己输入一个数）

输出print（电脑打印什么）

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

7、一行多文

Python 可以在同一行中使用多条语句，语句之间使用分号 ; 来分割

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

8、关于空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。

类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是 Python 语法的一部分。

书写时不插入空行，Python 解释器运行也不会出错，但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

9、多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句，在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \。

反斜杠

total = item_a + \
        item_b + \
        item_c

括号

total = ['item_a', 'item_b', 'item_c',
        'item_d']

10、import 与 from...import

在 python 用 import（某个模块） 或者 from...import （某个模块里面的某块）来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

11、命令行参数

很多程序可以执行一些操作来查看一些基本信息，Python可以使用-h参数查看各参数帮助信息

12、行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

例如

if True:
    print ("True")
else:
    print ("False")

而如果缩进不一样，会报错

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")   #这里else语块的print语句缩进不一样，所以会报错

13、注释

Python中单行注释以 # 开头

print（“hello，world”）#这是一个注释

多行注释可以用多个 # 号，还有 ''' 和 """

# 第一个注释
# 第二个注释
print（“hello，world”）
 
'''
第三注释
第四注释
'''
print（“hello，world”） 
"""
第五注释
第六注释
"""
print（“hello，world”）

四、基本数据类型

1、赋值

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

等号和数学上等号意义不同，但（==）和数学意义上的相同

counter = 1          # 整型变量
miles   = 100.0       # 浮点型变量
name    = "Tang"     # 字符串

print (counter)
print (miles)
print (name)

输出结果

 1    
100.0 
Tang

2、多个变量赋值

Python允许你同时为多个变量赋值

a=b=c=1

a，b，c=1，2，“hello”
#1被赋予a，2被赋予b，hello被赋予c

3、标准数据类型

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

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

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

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

1、Number数字类型：

int、float、bool、complex（复数）。在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。

a=1
print（a,type(a))

输出结果是

1 

可以用 isinstance 来判断

a=1
isinstance(a, int)
#输出结果True

isinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型。

isinstance()会认为子类是一种父类类型。

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

del删除

>>>a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

数值运算

>>> 1 +2  # 加法
3
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32
#/ 返回一个浮点数，// 返回一个整数。混合计算时，Python会把整型转换成为浮点数

Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

2、String（字符串）

Python中的字符串用单引号 ' 或双引号 " 括起来，多行用‘’‘--’‘’

>>>str='''hello world'''
>>>print(str)
hello world
>>>str='''hello
...world'''
>>>print(str)
hello
world
>>>str'hello
SyntaxError: incomplete input
>>>str"hello          #除了三引号可以写下一行，其他都不能
SyntaxError: incomplete input
>>>str='hello world'
>>>print(str)
hello world
>>>str='hello"
SyntaxError: incomplete input

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串。反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

>>> print('hello\nworld')
hello
world
>>> print(r'hello\nworld')
hello\nworld
>>>

Python 没有单独的字符类型，一个字符就是长度为1的字符串。与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = 'm' 会导致错误。

>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

3、bool（布尔类型）

只有两个值：True 和 False

可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。

.可以和逻辑运算符一起使用，包括 and（与）、or（或 ）和 not（非）。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。

可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。

>>>a = True
>>>b = False

# 比较运算符
>>>print(2 < 3)   # True
>>>print(2 == 3)  # False

# 逻辑运算符
>>>print(a and b)  # False
>>>print(a or b)   # True
>>>print(not a)    # False

# 类型转换
>>>print(int(a))   # 1
>>>print(float(b)) # 0.0
>>>print(str(a))   # "True"

在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。

4、List（列表）

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

t=[a,b,c,d]
   0,1,2,3
 -4,-3,-2,-1

加号 + 是列表连接运算符，星号 * 是重复操作

>>>list=['a',234,2.23,'d']   #List写在方括号之间，元素用逗号隔开
>>>tinylist=[234,'a',2.23,'d']
>>>print(list)
['a', 234, 2.23, 'd']
>>>print(list[0])
a
>>>print(list[1,3])
Traceback (most recent call last):
  File "", line 1, in 
    print(list[1,3])
TypeError: list indices must be integers or slices, not tuple
>>>print(list[1;3])
SyntaxError: invalid syntax
>>>print(list[1:3])
[234, 2.23]
>>>print(list[2:1])
[]
>>>print(list[2:])#从第三个开始
[2.23, 'd']
>>>print(list*2)
['a', 234, 2.23, 'd', 'a', 234, 2.23, 'd']
>>>print(list+tinylist)
['a', 234, 2.23, 'd', 234, 'a', 2.23, 'd']
>>>list[0]=9    #列表元数可以修改
>>>list[3]='f'
>>>list
[9, 234, 2.23, 'f']

5、Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

>>>tuple=('a',11,1.5,'hello',66.6)
>>>tinytuple=(6,'b')
>>>print(tupie)
Traceback (most recent call last):
  File "", line 1, in 
    print(tupie)
NameError: name 'tupie' is not defined. Did you mean: 'tuple'?
>>>print(tuple)
('a', 11, 1.5, 'hello', 66.6)
>>>print(tuple(0))
Traceback (most recent call last):
  File "", line 1, in 
    print(tuple(0))
TypeError: 'tuple' object is not callable
>>>print(tuple[0])
a
>>>print(tuple[2:3])
(1.5,)
>>>print(tuple[1:3])
(11, 1.5)
>>>print(tupie*2)
Traceback (most recent call last):
  File "", line 1, in 
    print(tupie*2)
NameError: name 'tupie' is not defined. Did you mean: 'tuple'?
>>>print(tuple*2)
('a', 11, 1.5, 'hello', 66.6, 'a', 11, 1.5, 'hello', 66.6)
>>>print(tuple+tinytuple)
('a', 11, 1.5, 'hello', 66.6, 6, 'b')
>>>tuple[0]=6
Traceback (most recent call last):
  File "", line 1, in 
>>>tuple[0]=6
TypeError: 'tuple' object does not support item assignment

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

6、Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式为：parame = {value01,value02,...} 或者 set(value)

>>>sites={'Google','Baidu','Zhihu','CSDN'}
>>>print(sites)     # 输出集合，重复的元素被自动去掉
{'Google', 'CSDN', 'Baidu', 'Zhihu'}
>>>if 'Baidu'in sites:
...    print('Baidu在集合中‘）
          
SyntaxError: incomplete input
>>>if 'Baidu' in sites:
...    print('Baidu 在集合中')
>>>else:
...    print('Baidu 不在集合中‘）
          
SyntaxError: incomplete input
>>>if 'Baidu' in sites:
...    print('Baidu 在集合中')
>>>else:
...    print('Baidu 不在集合中'）
          
SyntaxError: invalid character '）' (U+FF09)
>>>if 'Baidu' in sites:
...    print('Baidu 在集合中')
>>>else:
...    print('Baidu 不在集合中')

Baidu 在集合中


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

(上面代码我有好多典型的新手出错，大家可以引以为戒）

7、Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

>>>dict={}  #空集合
>>>dict[1]="1-我是小白"
>>>dict['two']='2-我是大白"
SyntaxError: incomplete input
>>>dict['two']="2-我是大白"
>>>tinydict={'name','year':20,'site'::'www.CSDN.com'}
SyntaxError: invalid syntax
>>>tinydict={'name':'CSDN','code':2,'site':'www.csdn.com'}
>>>print(dict[1])
1-我是小白
>>>print(dict['two'])
2-我是大白
>>>print(tinydict)
{'name': 'CSDN', 'code': 2, 'site': 'www.csdn.com'}
>>>print(tinydict.key())
Traceback (most recent call last):
  File "", line 1, in 
>>>print(tinydict.key())
AttributeError: 'dict' object has no attribute 'key'. Did you mean: 'keys'?
>>>print(tinydict.keys())
dict_keys(['name', 'code', 'site'])
>>>print(tinydict.values())
dict_values(['CSDN', 2, 'www.csdn.com'])

8、bytes 类型

bytes 类型表示的是不可变的二进制序列（byte sequence）。

与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀

此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码

与字符串类型类似，bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于 bytes 类型是不可变的，因此在进行修改操作时需要创建一个新的 bytes 对象。