100分钟掌握Python的基础知识

print('Hello World')

# 变量用于临时存储可能发生变化的数据
# 单一的等号是赋值运算符
age = 26
first_name = 'Shivika'
gpa = 3.99
# 在这里我们可以看到三个不同类型的数据存储在变量中：一个整数、一个字符串和一个浮点数。
# 你不需要声明存储在每个变量中的数据类型。Python 为你做了这些。
# 你可以使用type()函数查看变量中的数据类型
print(type(age))
print(type(first_name))
print(type(gpa))
# 变量是 "动态类型的"--Python在运行时检查类型。
age = 26.2
print(type(age))
print(age, type(age))
# 变量命名的提示。
# 命名可以有字母、数字和下划线，但不能以数字开头
# 一些Python保留字不能使用
# 使用描述性的变量名
# 大小写事项
# 常数用大写字母。PI = 3.14159
# 每一个Python变量都是一个指针，指向存储在内存某处的数据
# 使用id()函数获得一个变量的内存位置
print(id(age))
# 交换变量
x = 5
y = 10
x, y = y, x
print('x =', x, 'y =', y)

# 这些都是False：0, 0.0, [], "", None
# 这些都是True：任何非零的数字，任何非空的字符串、列表或集合
print(bool(1))    # True
print(bool('dog'))
print(bool(10.78))
print(bool(0 or 1))
print(bool(0))    # False
print(bool(''))
print(bool(0 and 1))

# 内置的算术函数有：加、减、乘、除、幂、整数除和模（又名：模或余数）。
# + 加法
# - 减法
# * 乘法
# / 除法
# // 整数除法
# % 模数(除法余数)
# ** 幂
x = 5 + 7
print(x, type(x))
x = 5 - 7
print(x, type(x))
x = 7 / 4
print(x, type(x))
x = 7 // 4
print(x, type(x))
x = 7 % 4
print(x)
x = 4 ** 3
print(x)
# x += 5 is the same as saying x = x + 5
x = 2
x = x + 5
print(x)
x = 2
x += 5
print(x)
# Order of Operations
#   1. ( )
#   2. **
#   3. * / // %
#   4. + -
#   Example: 1 + 5 ** (3 // 2) - 6 % 4 => 4
x = 1 + 5 ** (3 // 2) - 6 % 4
print(x)

# 从键盘上获取用户在命令提示符下的输入信息
name = input('What is your name? ')
print("Hello,", name)
age = eval(input('How old are you? '))
print('Age =', age, type(age))
# 用我们目前所知道的，我们可以写一个程序来获取用户的输入并计算三角形的面积。
base = eval(input('Enter the base: '))
height = eval(input('Enter the height: '))
area = base * height / 2
print ('Area = ', area)

# 单行注释的标签
'''
三组引号 
用于多行注释
'''
""" double quotes work too """

# 条件语句需要bool表达式
x = 69
print(x > 50)
print(x == 50)
print(x != 50)
my_age = 19
print(my_age > 21)
if my_age >= 21:
    print("Old enough.")
else:
    print("Not old enough.")
    print("Maybe next year.")
score = 72
if score > 90:
    print('Grade: A')
elif score > 80:
    print('Grade: B')
elif score > 70:
    print('Grade: C')
elif score > 60:
    print('Grade: D')
else:
    print('Grade: F')
# 在一个if中可以有多个条件，使用and/or
my_age = 19
grade = 'C'
if my_age > 18 and grade == 'A':
    print('I can go to the party!')
# 嵌套的if语句 -- 两个条件都必须为 "True"
my_age = 19
grade = 'C'
if my_age > 18:
    if grade == 'A':
        print('I can go to the party!')
# if ternary
x = 10
y = 20
#  action/ if condition true/ else condfition false
z = x + y if x > y else y - x
print(z)
# result 10

# 一个字符串是一串字符（即文本）
s = 'Howdy'
print(s)
print(len(s))
print(s[3])
print(s[1:3])
t = ' dude! '
s += t
print(s + '|')
print(s.strip() + '|')
s = s.rstrip('! ')
print(s)
s = 'Howdy dude!'
print(s.lower())
print(s.upper()[:5])
print(s.title())
print(s.replace('Howdy', 'Greetings'))
print(s)
print(s.count('d'))
print(s.find('w'))
print('dud' in s)
print('X' not in s)
print(s.startswith('How'))
print(s.endswith('cat'))
print(s > 'Honk')
print(s.isalpha())
print(s[0:4].isalpha())
print(s.isnumeric())
print(s.split())
print('5,7,9'.split(','))
print('73.294'.split('.'))
print(s[0], '\t', s[1], '\t', s[2])
print(s[:s.find(' ')] + '\n' + s[s.find(' ')+1:])

# 用于遍历一个字符串或列表的项目
# 缩进是很重要的。
# 每个从for缩进的语句都将在每次迭代中被执行
s = 'Raj'
for letter in s:
    print(letter)
for letter in s:
    print(letter, end='')
print()
# if 在一个for循环内，缩进是很重要的。
for pig in s:
    if pig != 'a':
        print(pig, end='')
print()
for i in range(len(s)):
    print(i, end='')
print()
for i in range(len(s)):
    print(s[i])
for i in range(len(s)-1, -1, -1):
    print(s[i])
print(s[::-1])
# while 循环是for 循环的一种替代方法
# 它们在每个迭代中检查一个布尔值，当布尔值为假时退出循环
x = 2
while x < 5:
    print('ha')
    x += 1

# 这些函数都适用于String、List和Tuple
# 索引 -- 使用其索引访问序列中的任何项目
x = 'frog'
print (x[3])            # prints 'g'
x = ['pig', 'cow', 'horse']
print (x[1])            # prints 'cow'
# 切片 -- 使用索引切出子字符串、子列表、子元组
# [start : end+1 : step]
x = 'computer'
print(x[1:4])           # items 1 to 3, 'omp'
print(x[1:6:2])         # items 1, 3, 5, 'opt'
print(x[3:])            # items 3 to end, 'puter'
print(x[:5])            # items 0 to 4, 'compu'
print(x[-1])            # last item, 'r'
print(x[-3:])           # last 3 items, 'ter'
print(x[:-2])           # all except last 2 items, 'comput'
# 添加/串联 -- 使用+合并2个相同类型的序列。
x = 'horse' + 'shoe'
print (x)               # prints 'horseshoe'    
x = ['pig', 'cow'] + ['horse']
print (x)               # prints ['pig', 'cow', 'horse']
# 乘法 -- 使用*对一个序列进行乘法。
x = 'bug' * 3
print (x)               # prints 'bugbugbug'
x = [8, 5] * 3
print (x)               # prints [8, 5, 8, 5, 8, 5]
# 检查成员 -- 测试一个项目是否在一个序列中
x = 'bug'
print ('u' in x)        # prints True
x = ['pig', 'cow', 'horse']
print ('cow' not in x)  # prints False
# 迭代 -- 迭代一个序列中的项目
x = [7, 8, 3]
for item in x:
    print (item * 2)    # prints 14, 16, 6
x = [7, 8, 3]
for index, item in enumerate(x):
    print (index, item) # prints 0 7, 1 8, 2 3
# 长度 -- 计算一个序列中的项目数
x = 'bug'
print (len(x))          # prints 3
x = ['pig', 'cow', 'horse']
print (len(x))          # prints 3
# Minimum -- 在一个序列中按字母顺序找到最小项
# 字母或数字类型，但不能混合类型
x = 'bug'
print (min(x))          # prints 'b' 
x = ['pig', 'cow', 'horse']
print (min(x))          # prints 'cow'
# Maximum -- find the maximum item in a sequence
# alpha or numeric types, but cannot mix types
x = 'bug'
print (max(x))          # prints 'u' 
x = ['pig', 'cow', 'horse']
print (max(x))          # prints 'pig'
# Sum -- find the sum of items in a sequence
# entire sequence must be numeric type
x = [5, 7, 'bug']
print (sum(x))          # error!
x = [2, 5, 8, 12]
print (sum(x))          # prints 27
print (sum(x[-2:]))     # prints 20 
# 排序 -- 返回一个排序后的新项目列表
# 排序后不会改变原始列表
x = 'bug'
print (sorted(x))       # prints ['b', 'g', 'u']
x = ['pig', 'cow', 'horse']
print (sorted(x))       # prints ['cow', 'horse', 'pig']
# count (item)  
# 返回一个项目的计数
x = 'hippo'
print (x.count('p'))    # prints 2
x = ['pig', 'cow', 'horse', 'cow']
print (x.count('cow'))  # prints 2
# index (item)  
# 返回一个项目的第一次出现的索引
x = 'hippo'
print (x.index('p'))    # prints 2
x = ['pig', 'cow', 'horse', 'cow']
print (x.index('cow'))  # prints 1
# 解包 - 将一个序列的n个项目解包为n个变量
x = ['pig', 'cow', 'horse']
a, b, c = x             # now a is 'pig', b is 'cow', c is 'horse'

# 创建一个新列表
x = list((1, 2, 3))     # note double parens
x = ['a', 25, 'dog', 8.43]
x = list(tuple1)
# 使用解析法创建列表
x = [m for m in range(8)]
# resulting list: [0, 1, 2, 3, 4, 5, 6, 7]
x = [z**2 for z in range(10) if z>4]
# resulting list: [25, 36, 49, 64, 81]
# 删除 -- 删除一个列表或列表中的一个项目
x = [5, 3, 8, 6]
del(x[1])               # [5, 8, 6]
del(x)                  # deletes list x
# Append -- 将一个项目追加到列表中
x = [5, 3, 8, 6]
x.append(7)             # [5, 3, 8, 6, 7]
# 延伸 -- 将一个序列追加到一个列表上
x = [5, 3, 8, 6]
y = [12, 13]
x.extend(y)             # [5, 3, 8, 6, 7, 12, 13]
# Insert -- 在给定的索引处插入一个项目。 x.insert(index, item)
x = [5, 3, 8, 6]
x.insert(1, 7)          # [5, 7, 3, 8, 6]
x.insert(1,['a','m'])   # [5, ['a', 'm'], 7, 3, 8, 6] 
# Pop -- 从列表中弹出最后一个项目，并返回项目
x = [5, 3, 8, 6]
x.pop()                 # [5, 3, 8]. and returns the 6
print(x.pop())          # [5, 3]. and prints 8 
# 移除 -- 移除一个项目的第一个实例
x = [5, 3, 8, 6, 3]
x.remove(3)             # [5, 8, 6, 3]
# 反转 -- 反转列表的顺序
x = [5, 3, 8, 6]
x.reverse()             # [6, 8, 3, 5]
# 排序 -- 将列表排序到位
# sorted(x) 返回一个新的排序的列表，而不改变原来的列表 x。
# x.sort() 将x的项目按排序顺序排列（原地排序）。
x = [5, 3, 8, 6]
x.sort()                # [3, 5, 6, 8]
# 清除 -- 删除列表中的所有项目
x = [5, 3, 8, 6]
x.clear()               # []

# 构造函数 - 创建一个新元组
x = ()                  # no-item tuple
x = (1,2,3)
x = 1, 2, 3             # parenthesis are optional
x = 2,                  # single-item tuple
list1 = [5, 7, 7]
x = tuple(list1)        # tuple from list
# 元组是不可变的，但成员对象可能是可变的
x = (1, 2, 3)
del(x[1])               # error!
x[1] = 8                # error!
x = ([1,2], 3)          # 2-item tuple: list and int
del(x[0][1])            # ([1], 3)
# 集合
# ------------------------------------------------
# 构造函数 - 创建一个新的集合
x = {3,5,3,5}           # {5, 3}
x = set()               # empty set
list1 = [5, 7, 7]
x = set(list1)          # new set from list. strips duplicates, {5, 7}
# Set Comprehension
x = {3*x for x in range(10) if x>5} 
#产生的集合。{18, 21, 24, 27}但顺序是随机的

# 构造函数 - 创建一个新的dict
x = {'pork':25.3, 'beef':33.8, 'chicken':22.7}
x = dict([('pork', 25.3),('beef', 33.8),('chicken', 22.7)])
x = dict(pork=25.3, beef=33.8, chicken=22.7)
# 访问dict中的键和值
x.keys()                # returns list of keys in x
x.values()              # returns list of values in x
x.items()               # returns list of key-value tuple pairs in x
item in x.values()      # tests membership in x, returns boolean
# 迭代一个Dict
for key in x:           # iterate keys
    print(key, x[key])  # print all key/value pairs
for k, v in x.items():  # iterate key/value pairs
    print(k, v)         # print all key/value pairs

# 使用 def 关键字来创建一个函数
# 给函数一个名字，后面加括号和冒号
# 你可以传入0个或多个变量，这里我们传入num。
# 你可以返回0个或多个变量，这里我们返回num的立方体。
# 缩进是很重要的。
def cuber(num):
    num_cubed = num * num * num
    return num_cubed
# to call the function, and pass in 5:
cuber(5)
# but if you want to assign the return value (125) to a variable,
x = 5
x_cubed = cuber(x)
print(x, x_cubed)
# you can set default values for parameters
def cuber(num = 2):
    num_cubed = num * num * num
    return num_cubed
print(cuber())      # uses the default 2
print(cuber(3))     # 3 overrides the default
# you can pass in multiple values, and return multiple values
# but order is important
def solve_triangle(base, height, side1, side2, side3):
    area = base * height / 2
    perimeter = side1 + side2 + side3
    return area, perimeter
area, perim = solve_triangle(3, 4, 5, 3, 4) # b=3, h=4, s1=5, s2=3, s3=4
print('Area:', area, ' Perimeter:', perim)
# 以上都被称为 "位置参数"，而且顺序很重要
# 你也可以在调用一个函数时传递 "关键字参数"。
a, p = solve_triangle(side1=5, side2=3, side3=4, height=4, base=3)
print(a, p)
# 或者使用两者的组合，但位置参数必须放在前面
a, p = solve_triangle(3, 4, side3=4, side2=3, side1=5)
print(a, p)

# 使用类来模拟现实世界的事物。
# 把相关的数据（变量）和动作（函数）放在一个代码块中。
class Circle:
    # Circle constructor -- __init__ method creates a new Circle object
    def __init__(self, r = 1):
        self.radius = r
    def getPerimeter(self):
        return 2 * self.radius * 3.14
    def getArea(self):
        return self.radius ** 2 * 3.14
# 所有的方法都有self参数，它是Python对调用该方法的对象的引用。
# 这将调用 __init__ 方法，它将创建新的 Circle
circle1 = Circle(3)     
# 你可以使用点运算符访问圆的属性和方法
print("Radius =", circle1.radius)
print("Perimeter =", circle1.getPerimeter())

# Python 有许多已经写好的类，你可以使用它们
# 要访问另一个类中的方法和数据，你必须导入它
import math
print(math.pi)
import random
print(random.randint(1,5))
# 更短的版本，用as来缩写模块的名称
import math as m
print(m.pi)
import random as rd
print(rd.randint(1,5))
# 只导入一两个函数或常量，而不是整个模块
# 更容易编码，但需要注意名称不冲突
from math import pi
print(pi)
from random import randint, shuffle
print(randint(1,5))
x = ['a', 'b', 'c']
shuffle(x)
print(x)
# 如果你愿意，可以重命名一个导入的函数
x = ['a', 'b', 'c']
from random import shuffle as sf
sf(x)
print(x)
#也可以用*导入整个模块
from random import *
print(randint(1,5))

filename = 'city_data.txt'
# 这将打开一个名为fin的文件句柄，遍历文件的每一行，并打印每一行
with open(filename) as fin:
    for line in fin:
        print(line)
# 我们可以通过使用split从一行中抓取单词，它将每一行变成一个叫做row的列表
with open(filename) as fin:
    fin.readline()
    for line in fin:
        row = line.split(',')
        print('Country:', row[1], ' City:', row[2])
# 使用w参数写入一个输出文件
with open('Cities.txt', 'w') as fout:
    with open(filename) as fin:
        fin.readline()
        for line in fin:
            row = line.split(',')
            fout.write(row[2] + '\n')