10分钟掌握python安装上手和基本的数据结构（小白篇）

1. Python安装
2. pycharm安装
3. pycharm破解

4. 变量

5. 注释

6. 数据类型

7. 字符串(str)

8. 整数(int)

9. 浮点型(float)

10. 布尔(bool)

11. 列表

12. 元组

13. 集合

14. 字典

先来安装python：https://www.python.org/ 

第3个，管理员身份运行，安装完控制台输入python -v查看安装是否成功

接下来安装pycharm： https://www.jetbrains.com.cn/en-us/pycharm/

这个安装完先不要着急打开，先去找破解的验证码：http://jets.idejihuo.com/

然后进来可以开始写代码了，这个里面建项目和idea差不多

然后兄弟们你们根据下面的这些代码写，一个个测试就知道是什么意思了

## 注释

# 这是Python中的行注释

'''

这是Python中三个单引号的块注释

'''

"""

这是Python中三个双引号的块注释

"""

## 数据类型 

```python

# python：是一门动态的强类型语言

a = "str"

b = 1.0

# java：是一门静态的强类型语言

int i =1

double d=2.0

# javascript：是一门动态的弱类型语言，运行时识别数据类型

let a=1;

let b="str";

```

### 字符串(str)

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

```python

# 单引号和双引号

temp = 'hello python'

temp = "hello python"

print(temp)

temp = 'I say "hello world"'

print(temp)

# 转义符处理

temp="I say \"hello world\""

print(temp)

# 通过+拼接字符串

print(temp+"...")

# 使用制表符\t和换行符\n

print("I say \thello \nworld")

```

 

 ### 整数(int)

在Python中，可对整数执行加（+）减（-）乘（*）除（/）运算。

```python

# 加（+）减（-）乘（*）除（/）运算

count = 8

print(count+1)

print(count-1)

print(count/2)

print(count*2)

# 使用两个乘号表示乘方运算

print(count ** 2)  # 相当于count * count

# 符号*打印输出30次

print("*"*30)

```

 ### 浮点型(float)

Python将带小数点的数字都称为浮点数。

```python

salary=3000

print(salary);

```

不同数据类型与str拼接，需要进行类型转换处理：

```python

print("我的工资是："+str(salary))

# print('1'+3)       X

# print(int('1')+3)  √

# print('1'+str(3))  √

```

> 在字符串中使用整数时，需要显式地指出将这个整数用作字符串。str()

浮点型的缺陷：

```python

a = 0.1

b = 0.2

print(b-a)  # 0.1

print(a+b)  # 0.30000000000000004

```

> 温馨提示：计算机系统底层采用二级制，而整数（1,2,3,4等）都能完美的转换成二进制，但是小数（浮点数）有可能变成无限二进制（**精度的丢失问题**）

所以说，只要是float类型的数据相加，无论在任何语言、任何数据库、任何中间件中进行加法(减法乘除法)运算，得到的数据，都不会精确。

**解决方案：**

- 数据库中使用decimal类型（字符小数，例如：'1.1111'），在Java中使用BigDecimal进行计算操作；

- 以最小单位存储，例如：1.236(一块二毛三分六厘)，1236(以最小单位厘来存储)；

 

### 布尔(bool)

 

Python提供了 bool 类型来表示真（对）或假（错），比如常见的`5 > 3`比较算式，这个是正确的，在程序世界里称之为真（对），Python 使用 **True** 来代表；再比如`4 > 20`比较算式，这个是错误的，在程序世界里称之为假（错），Python 使用 **False** 来代表。

> 配合运算符：`>=，<=，==，!=，and，or` 一起使用。

 

## 列表

 

需要明确的是，Python中没有数组，但是加入了更加强大的列表。如果把数组看做是一个集装箱，那么 Python 的列表就是一个工厂的仓库。

从形式上看，列表会将所有元素都放在一对中括号`[ ]`里面，相邻元素之间用逗号`,`分隔，如下所示：

```python

nums=[0,1,2,3,4,5,6,7,8,9]

```

- 常规操作

```python

# 1) 查看names的大小

print(len(nums))

# 2) 取值，从头到尾取值，索引从0开始

print(nums[0])

# 3) 取值，从尾到头取值，索引从-1开始

print(nums[-1])

# 4) 赋值

nums[0]="zhaoliu"

print(nums)

nums[-2]="wahaha"

print(nums)

```

- 追加append：在列表末尾添加元素

```python

nums.append(100)

print(nums)

```

- 插入insert：在列表中插入元素

```python

nums.insert(0,666)

print(nums)

nums.insert(-2,777)

print(nums)

```

- 删除del

```python

del nums[0]

print(nums)

```

- 删除（出栈方式）pop：出栈|根据索引删除

```python

# 默认从最后一个开始出栈

print(nums.pop())

# 通过指定索引下表出栈

print(nums.pop(0))

print(nums)

```

- 删除remove：根据元素删除

```python

# remove删除

nums.remove(5)

print(nums)

# 判断元素是否存在

print(5 in nums)

print(5 not in nums)

```

> 方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

- 排序

```python

# 临时性排序

print(sorted(nums))

# 永久性排序

nums.sort()

print(nums)

```

- 反转

```python

nums.reverse()

print(nums)

```

- 切片

start和stop的正值代表列表下标，负值代表列表从右往左数起，倒数第几个数据。方向由step确定，step为正时，从左往右切片，step为负时，从右往左切片；start和stop的空值分别代表列表的头尾的最后一个数据，至于start和stop空值的时候代表的是列；表的头还是尾，由step的正负值决定，即由step确定列表切片的方向后决定。

```python

# start：起始下标

# stop：停止下标

# step：步长

# start和stop的正值代表列表下标

print(nums[::2])

print(nums[1::2])

print(nums[0:4:2])

# start和stop负值代表列表从右往左数起，不包含结束位置

print(nums[-1:-3:-1])

# 单独一个冒号,代表从头取到尾,步长默认为1

print(nums[:])

# 单独两个冒号一样代表从头取到尾,步长默认为1

print(nums[::])

# 两个冒号后面是步长。步长为1，从左到右；步长为-1，从右到左

print(nums[::1])

print(nums[::-1])

# 赋值操作

# nums[0:4]=[]

nums[0:4]=[1,2]

print(nums)

```

 

## 元组

元组（tuple）是Python中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。

元组和列表（list）的不同之处在于：

- 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；

- 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。

从形式上看，元组的所有元素都放在一对小括号`( )`中，相邻元素之间用逗号`,`分隔，如下所示：

```python

nums=(0,1,2)

a,b,c=nums

print(a)

print(b)

print(c)

print(len(nums))

print(nums)

# tuple类型一旦初始化就不能修改

# nums[0]=5

# print(nums)

```

## 集合

 

Python中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。

从形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：

```python

# 创建一个空的set集合

# cities = set()

# 使用{}创建带有数据的set集合且不能重复

cities = {'hunan', 'shanghai', 'beijing','hunan'}

print(cities)

# 出栈，随机

print(cities.pop())

# 指定删除，remove删除不存在的元素则报错

# cities.remove("hunan")

# 判断元素是否存在

if "hunan" in cities:

    cities.remove("hunan")

# discard删除不存在的元素不报错

cities.discard("beijing")

# clear代表清除

cities.clear()

print(cities)

# 集合运算

a = {1, 2, 3, 4}

b = {3, 4, 5, 6}

# a-b的差集

print('a-b的差集：'+str(a - b))

# b-a的差集

print('b-a的差集：'+str(b - a))

# a和b的并集

print('a | b的并集：'+str(a | b))

# a和b的交集

print('a & b的交集：'+str(a & b))

# a和b的对称差集

print('a ^ b的对称差集：'+str(a ^ b))

```

## 字典

 

Python字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。

在Python中，字典用放在花括号{}中的一系列键—值对表示。(与JSON类似)

```python

person={

    "name":"张三",

    "age":21,

    "salary":3000

}

print(person["name"])

print(person["age"])

print(person["salary"])

person["score"]=90

print(person)

```