def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

变量[头下标:尾下标] # 索引值 0 表示开头，-1 表示结尾 ; 使用 + 连接字符串，使用 * 复制字符串

变量[头下标:尾下标]  # 索引值 0 表示开头，-1 表示结尾 ; 使用 + 连接操作，使用 * 复制操作

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

number = 7
guest = -1
while guest != number:
    guest = int(input("input a number:"))

    if guest == number:
        print ("right")
    elif guest < number:
        print ("smaller")
    elif guest > number:
        print ("bigger")

# coding=utf-8
num = int(input("输入一个数字："))
if num % 2 == 0:
    if num % 3 == 0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num % 3 == 0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")

#!/usr/bin/env python3
 
n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))

#!/usr/bin/python3
 
sites = ["Baidu", "Google","Str","Taobao"]
for site in sites:
    if site == "Str":
        print("Str!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

a = ['Google', 'Baidu', 'Str', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i, a[i])

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:	# for 循环遍历
    print (x, end=" ")

#!/usr/bin/python3
 
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

def 函数名（参数列表）:
    函数体

#!/usr/bin/python3
 
# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

#!/usr/bin/python3
 
def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print( b ) # 结果是 2

#!/usr/bin/python3
 
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "关键字参数")

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="Tom" )

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="Tom" )
print ("------------------------")
printinfo( name="Tom" )

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

输出: 
70
(60, 50)

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

def functionname(a,b,*,c):
     "函数_文档字符串"
   function_suite
   return [expression]

def f(a,b,*,c):
     return a+b+c
    
f(1,2,3)   # 错误调用
f(1,2,c=3) # 正确调用

lambda [arg1 [,arg2,.....argn]]:expression

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

#!/usr/bin/python3
 
# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

# 从模块中导入部分/全部部件
from moduel import * 
import module

person = {
  "name": "Tom",
  "age": 10,
  "country": "China"
}

import mymodule
a = mymodule.person["name"]
print(a)

from oslo_log import log as logging

import platform

x = dir(platform)
print(x)

class Person:
    def __init__(self):
        pass
    age = 10
    name = "Tom"

person = Person()
person = Person
print(str(person.age) + person.name)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age


person = Person("Tom", 10)

print(person.name)
print(person.age)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def my_func(self):
        print("Hello my name is " + self.name)


person = Person("Tom", 10)

person.my_func()

class DerivedClassName(BaseClassName1):

# 类定义
class People:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s say: i am %d years old" % (self.name, self.age))


# 单继承示例
class Student(People):
    # 成员私有属性
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        People.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s say: i am %d years old,i am  %d class" % (
            self.name, self.age, self.grade))


s = Student('Tom', 10, 60, 3)
s.speak()

class DerivedClassName(Base1, Base2, Base3):

#!/usr/bin/python3

# 类定义
class People:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.__weight = weight

    def speak(self):
        print("%s say: i am %d years old." % (self.name, self.age))


# 单继承示例
class Student(People):
    grade = ''

    def __init__(self, name, age, weight, grade):
        # 调用父类的构函
        People.__init__(self, name, age, weight)
        self.grade = grade

    # 覆写父类的方法
    def speak(self):
        print("%s say: i am %d years old,i am %d class." % (
            self.name, self.age, self.grade))


class Speaker():
    topic = ''
    name = ''

    def __init__(self, name, topic):
        self.name = name
        self.topic = topic

    def speak(self):
        print("my name is %s,i am a speaker,the topic is %s" % (
            self.name, self.topic))


# 多重继承
class Sample(Speaker, Student):
    a = ''

    def __init__(self, name, age, weight, grade, topic):
        Student.__init__(self, name, age, weight, grade)
        Speaker.__init__(self, name, topic)


test = Sample("Tom", 25, 80, 4, "Python")
test.speak()  # 方法名同,默认调用的是在括号中排前地父类的方法

import builtins
dir(builtins)

f = open("demofile.txt")
f = open("demofile.txt", "rt")

f = open("demofile.txt", "r")
# read 默认读取整个文件
print(f.read())
# 读取文件一行
f = open("demofile.txt", "r")
print(f.readline())
# 循环读取整个文件
f = open("demofile.txt", "r")
for x in f:
  print(x)
# 关闭文件
f.close()

import os
if os.path.exists("demofile.txt"):
  os.remove("demofile.txt")
else:
  print("The file does not exist")

import os
os.rmdir("myfolder")

import os

import glob
glob.glob('*.py')

import sys
print(sys.argv)

import re
re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')

import math
math.cos(math.pi / 4)

math.log(1024, 2)

import random

from urllib.request import urlopen
import smtplib

from datetime import date

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)

import unittest

class TestStatisticalFunctions(unittest.TestCase):

    def test_average(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
        self.assertRaises(ZeroDivisionError, average, [])
        self.assertRaises(TypeError, average, 20, 30, 70)

unittest.main() # Calling from the command line invokes all tests

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="root",
  passwd="root"
)

print(mydb)

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="root",
  passwd="root"
)

mycursor = mydb.cursor()

# 创建数据库
mycursor.execute("CREATE DATABASE test")

# 查询数据库是否存在
mycursor.execute("SHOW DATABASES")
for x in mycursor:
  print(x)

# 创建数据表
mycursor.execute("CREATE TABLE customers (id INT AUTO_INCREMENT PRIMARY KEY, "
"name VARCHAR(255), address VARCHAR(255))")

# 查询数据表
mycursor.execute("SHOW TABLES")
for x in mycursor:
  print(x)

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="root",
  passwd="root"
)

mycursor = mydb.cursor()

# 插入数据
sql = "INSERT INTO customers (name, address) VALUES (%s, %s)"
val = ("Tom", "China")
mycursor.execute(sql, val)
# 对插入操作进行提交,提交之后数据表才会发生变化
mydb.commit()
print(mycursor.rowcount, "record inserted.")
print("1 record inserted, ID:", mycursor.lastrowid)

# 插入多行数据
sql = "INSERT INTO customers (name, address) VALUES (%s, %s)"
val = [
  ('Peter', 'Lowstreet 4'),
  ('Amy', 'Apple st 652'),
  ('Hannah', 'Mountain 21'),
  ('Michael', 'Valley 345'),
  ('Sandy', 'Ocean blvd 2'),
  ('Betty', 'Green Grass 1'),
  ('Richard', 'Sky st 331'),
  ('Susan', 'One way 98'),
  ('Vicky', 'Yellow Garden 2'),
  ('Ben', 'Park Lane 38'),
  ('William', 'Central st 954'),
  ('Chuck', 'Main Road 989'),
  ('Viola', 'Sideway 1633')
]
mycursor.executemany(sql, val)
mydb.commit()
print(mycursor.rowcount, "was inserted.")

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="yourusername",
  passwd="yourpassword",
  database="mydatabase"
)
mycursor = mydb.cursor()
mycursor.execute("SELECT * FROM customers")
# fetchall 从最后执行的语句中获取所有行
myresult = mycursor.fetchall()
for x in myresult:
  print(x)

# 查询指定列的数据
mycursor.execute("SELECT name, address FROM customers")
myresult = mycursor.fetchall()
for x in myresult:
  print(x)

# 返回查询结果的第一行
mycursor.execute("SELECT * FROM customers")
myresult = mycursor.fetchone()
print(myresult)

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="yourusername",
  passwd="yourpassword",
  database="mydatabase"
)

mycursor = mydb.cursor()
sql = "DELETE FROM customers WHERE address = 'Mountain 21'"
mycursor.execute(sql)
# commit 提交修改
mydb.commit()
print(mycursor.rowcount, "record(s) deleted")

# 使用占位符 %s
sql = "DELETE FROM customers WHERE address = %s"
adr = ("Yellow Garden 2", )
mycursor.execute(sql, adr)
mydb.commit()
print(mycursor.rowcount, "record(s) deleted")

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="yourusername",
  passwd="yourpassword",
  database="mydatabase"
)

mycursor = mydb.cursor()
sql = "DROP TABLE customers"
mycursor.execute(sql)

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="yourusername",
  passwd="yourpassword",
  database="mydatabase"
)

mycursor = mydb.cursor()
sql = "UPDATE customers SET address = 'Canyon 123' WHERE address = 'Valley 345'"
mycursor.execute(sql)
mydb.commit()
print(mycursor.rowcount, "record(s) affected")

# 使用占位符 %s
sql = "UPDATE customers SET address = %s WHERE address = %s"
val = ("Valley 345", "Canyon 123")
mycursor.execute(sql, val)
mydb.commit()
print(mycursor.rowcount, "record(s) affected")